Changes

[AMDGPU] removed unused functions from printf lowering
Differential Revision: https://reviews.llvm.org/D66117
llvm-svn: 368633

Do not call replaceAllUsesWith to upgrade calls to ARC runtime functions
to intrinsic calls
This fixes a bug in r368311.
It turns out that the ARC runtime functions in the IR can have pointer 
parameter types that are not i8* or i8**. Instead of RAUWing normal 
functions with intrinsics, manually bitcast the arguments before passing 
them to the intrinsic functions and bitcast the return value back to the 
type of the original call instruction.
rdar://problem/54125406
llvm-svn: 368634

[X86] Remove 'Server' from Tigerlake description comments.
Tigerlake is a client CPU not a server CPU.
llvm-svn: 368635

Move findBBwithCalls to the file it's used in to avoid unused function
warnings.
llvm-svn: 368636

Revert "Do not call replaceAllUsesWith to upgrade calls to ARC runtime
functions"
This reverts commit r368634 because it broke a bot.
llvm-svn: 368637

[Symbol] Remove redundant include
llvm-svn: 368638

clang-scan-deps: do not spawn threads when LLVM_ENABLE_THREADS is
disabled
llvm-svn: 368640

[TSan] Fix test failing on Linux
llvm-svn: 368641

Eliminate implicit Register->unsigned conversions in VirtRegMap. NFC
Summary: This was mostly an experiment to assess the feasibility of
completely eliminating a problematic implicit conversion case in D61321
in advance of landing that* but it also happens to align with the goal
of propagating the use of Register/MCRegister instead of unsigned so I
believe it makes sense to commit it.
The overall process for eliminating the implicit conversions from 
Register/MCRegister -> unsigned was to: 1. Add an explicit conversion to
support genuinely required conversions to
  unsigned. For example, using them as an index for IndexedMap. Sadly
it's
  not possible to have an explicit and implicit conversion to the same
  type and only deprecate the implicit one so I called the explicit
  conversion get(). 2. Temporarily annotate the implicit conversion to
unsigned with
  LLVM_ATTRIBUTE_DEPRECATED to make them visible 3. Eliminate implicit
conversions by propagating Register/MCRegister/
  explicit-conversions appropriately 4. Remove the deprecation added in
2.
* My conclusion is that it isn't feasible as there's too much code to
 update in one go.
Depends on D65678
Reviewers: arsenm
Subscribers: MatzeB, wdng, hiraditya, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D65685
llvm-svn: 368643

[lld] Remove unnecessary "class Lazy"
llvm-svn: 368644

[AMDGPU] Fix msan failure in printf lowering
llvm-svn: 368645

Do not call replaceAllUsesWith to upgrade calls to ARC runtime functions
to intrinsic calls
This fixes a bug in r368311.
It turns out that the ARC runtime functions in the IR can have pointer 
parameter types that are not i8* or i8**. Instead of RAUWing normal 
functions with intrinsics, manually bitcast the arguments before passing 
them to the intrinsic functions and bitcast the return value back to the 
type of the original call instruction.
This recommits r368634, which was reverted in r368637. The loop in the 
patch was iterating over uses of a function and deleting function calls 
inside it, which caused bots to crash.
rdar://problem/54125406
Differential Revision: https://reviews.llvm.org/D66047
llvm-svn: 368646

Verifier: check prof branch_weights
This patch is to check some of constraints on
!pro branch_weights metadata: 
https://llvm.org/docs/BranchWeightMetadata.html
Reviewers: asbirlea, reames, chandlerc Reviewed By: reames Differential
Revision: https://reviews.llvm.org/D61179
llvm-svn: 368647

[GlobalISel]: Add KnownBits for G_XOR
https://reviews.llvm.org/D66119
llvm-svn: 368648

[ELF][test] Add dynamic-list-preempt2.s
When producing a DSO, the isPreemptible property of a Defined with 
default or protected visibility is affected by the --dynamic-list file, 
but not by interposable symbols in other DSOs.
llvm-svn: 368649

Added unit tests to check supported rounding modes
Also added fixed misspelled metadata name.
Differential Revision: https://reviews.llvm.org/D66073
llvm-svn: 368650

[ELF] Rename odd variable names "New" after r365730. NFC
New -> newSym or newFlags
Reviewed By: atanasyan
Differential Revision: https://reviews.llvm.org/D66127
llvm-svn: 368651

[GlobalISel] Make the InstructionSelector instance non-const, allowing
state to be maintained.
Currently we can't keep any state in the selector object that we get
from subtarget. As a result we have to plumb through all our variables
through multiple functions. This change makes it non-const and adds a
virtual init() method to allow further state to be captured for each
target.
AArch64 makes use of this in this patch to cache a call to
hasFnAttribute() which is expensive to call, and is used on each
selection of G_BRCOND.
Differential Revision: https://reviews.llvm.org/D65984
llvm-svn: 368652

[AArch64][GlobalISel] Replace explicit vreg creation with implicit using
SrcOp. NFC.
llvm-svn: 368653

[PowerPC] Fix ICE when truncating some vectors
The legalizer would hit an assertion on PowerPC platform when truncating 
a vector whose size is not power of 2.  This patch is to add a check to 
prevent vectors with such odd-size elements from being custom lowered.
Reviewed By: Hal Finkel
Differential Revision: https://reviews.llvm.org/D65261
llvm-svn: 368654

[ASTImporter] Import additional flags for functions.
Summary: At AST import of function delcarations import the flags for
defaulted and deleted.
Reviewers: martong, a.sidorin, shafik, a_sidorin
Reviewed By: a_sidorin
Subscribers: rnkovacs, dkrupp, Szelethus, gamesh411, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D65999
llvm-svn: 368655

[NFC][InstCombine] Non-canonical clamp pattern: non-canonical predicate
tests
We can't handle 'uge' case because we can't ever get it, there needs to
be extra use on that compare or else it will be canonicalized, but
because of extra use we can't handle it.
'sge' case we can have.
llvm-svn: 368656

[SimplifyLibCalls] Add dereferenceable bytes from known callsites
Summary: int mm(char *a, char *b) {
   return memcmp(a,b,16);
}
Currently: define dso_local i32 @mm(i8* nocapture readonly %a, i8*
nocapture readonly %b) local_unnamed_addr #1 { entry:
 %call = tail call i32 @memcmp(i8* %a, i8* %b, i64 16)
 ret i32 %call
}
After patch: define dso_local i32 @mm(i8* nocapture readonly %a, i8*
nocapture readonly %b) local_unnamed_addr #1 { entry:
 %call = tail call i32 @memcmp(i8* dereferenceable(16)  %a, i8*
dereferenceable(16)  %b, i64 16)
 ret i32 %call
}

 Reviewers: jdoerfert, efriedma
Reviewed By: jdoerfert
Subscribers: javed.absar, spatel, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D66079
llvm-svn: 368657

[NFC] Updated tests after r368657
llvm-svn: 368658

[ELF] Simplify handling of exportDynamic and isPreemptible
In Writer::includeInDynSym(), exportDynamic is used by a Defined with 
protected or default visibility, to record whether it is required to be 
exported into .dynsym. It is set when any of the following conditions 
hold:
1) There is an interposable symbol from a DSO (Undefined or SharedSymbol
with default visibility) 2) If -shared or --export-dynamic is specified,
any symbol in an object file/bitcode sets this property, unless
suppressed by canBeOmittedFromSymbolTable(). 3) --dynamic-list when
producing an executable
4) protected symbol from a DSO preempted by copy relocation/canonical
PLT when
 --ignore-{data,function}-address-equality is specified 5) ifunc is
exported when -z ifunc-noplt is specified
Bullet points 4) and 5) are irrelevant in this patch.
Bullet 3) does not play well with 1) and 2). When -shared is specified, 
exportDynamic of most symbols is true. This makes it incapable to record
--dynamic-list marked symbols. We thus have obscure:
    if (!config->shared)
     b->exportDynamic = true;
   else if (b->includeInDynsym())
     b->isPreemptible = true;
This patch adds another bit `Symbol::inDynamicList` to record 3). We can
thus simplify handleDynamicList() by unifying the DSO and
 executable cases. It also allows us to simplify isPreemptible - now the
field is only used in finalizeSections() and later stages.
Reviewed By: peter.smith
Differential Revision: https://reviews.llvm.org/D66091
llvm-svn: 368659

Revert r368276 "[TargetLowering] SimplifyDemandedBits - call
SimplifyMultipleUseDemandedBits for ISD::EXTRACT_VECTOR_ELT"
This introduced a false positive MemorySanitizer warning about use of 
uninitialized memory in a vectorized crc function in Chromium. That
suggests maybe something is not right with this transformation. See 
https://crbug.com/992853#c7 for a reproducer.
This also reverts the follow-up commits r368307 and r368308 which 
depended on this.
> This patch attempts to peek through vectors based on the demanded
bits/elt of a particular ISD::EXTRACT_VECTOR_ELT node, allowing us to
avoid dependencies on ops that have no impact on the extract.
>
> In particular this helps remove some unnecessary
scalar->vector->scalar patterns.
>
> The wasm shift patterns are annoying - @tlively has indicated that the
wasm vector shift codegen are to be refactored in the near-term and
isn't considered a major issue.
>
> Differential Revision: https://reviews.llvm.org/D65887
llvm-svn: 368660

[ELF] Don't special case symbolic relocations with 0 addend to ifunc in
writable locations
Currently the following 3 relocation types do not trigger the creation 
of a canonical PLT (which changes STT_GNU_IFUNC to STT_FUNC and 
redirects all references):
1) GOT-generating (`needsGot`) 2) PLT-generating (`needsPlt`) 3) R_ABS
with 0 addend in a writable location. This is used for
 for ifunc function pointers in writable sections such as .data and
.toc.
This patch deletes case 3) to simplify the R_*_IRELATIVE generating 
logic added in D57371. Other advantages:
* It is guaranteed no more than 1 R_*_IRELATIVE is created for an ifunc.
* PPC64: no need to special case ifunc in toc-indirect to toc-relative
relaxation. See D65755
The deleted elf::addIRelativeRelocs demonstrates that one-pass scan 
through relocations makes several optimizations difficult. This is 
something we can think about in the future.
Reviewed By: peter.smith
Differential Revision: https://reviews.llvm.org/D65995
llvm-svn: 368661

[X86] SimplifyDemandedVectorElts - attempt to recombine target shuffle
using DemandedElts mask (reapplied)
If we don't demand all elements, then attempt to combine to a simpler
shuffle.
At the moment we can only do this if Depth == 0 as
combineX86ShufflesRecursively uses Depth to track whether the shuffle
has really changed or not - we'll need to change this before we can
properly start merging combineX86ShufflesRecursively into
SimplifyDemandedVectorElts. 
The insertps-combine.ll regression is because
XFormVExtractWithShuffleIntoLoad can't see through shuffles of different
widths - this will be fixed in a follow-up commit.
Reapplying this as rL368307 had to be reverted as part of rL368660 to
revert rL368276
llvm-svn: 368662

[X86] XFormVExtractWithShuffleIntoLoad - handle shuffle mask scaling
If the target shuffle mask is from a wider type, attempt to scale the
mask so that the extraction can attempt to peek through.
Fixes the regression mentioned in rL368662
Reapplying this as rL368308 had to be reverted as part of rL368660 to
revert rL368276
llvm-svn: 368663

[libc++] Use [[nodiscard]] for lock_guard, as an extension
Summary: D64914 added support for applying [[nodiscard]] to
constructors. This commit uses that capability to flag incorrect uses of
std::lock_guard where one forgets to actually create a variable for the
lock_guard.
rdar://45790820
Reviewers: mclow.lists, EricWF
Subscribers: christof, jkorous, dexonsmith, libcxx-commits, Quuxplusone,
lebedev.ri
Tags: #libc
Differential Revision: https://reviews.llvm.org/D65900
llvm-svn: 368664

gn build: Make sync script group output by revision
Differential Revision: https://reviews.llvm.org/D66090
llvm-svn: 368665

[libc++] Fix incorrect UNSUPPORTED annotation
The test was marked as UNSUPPORTED for clang-6 and clang-6, instead of 
clang-6 and clang-7.
llvm-svn: 368666

gn build: Give cmake sync script an opt-in --write flag
Differential Revision: https://reviews.llvm.org/D66101
llvm-svn: 368667

gn build: Merge r368630
llvm-svn: 368668

gn build: Extract git() and git_out() functions in sync script
llvm-svn: 368671

[pstl] Rename PARALLELSTL_BACKEND to PSTL_PARALLEL_BACKEND
It makes more sense to name configuration options as PSTL_XXX. Also, I'm
naming it PSTL_PARALLEL_BACKEND because we might introduce the ability
to customize the vectorization backend, in which case PSTL_BACKEND would
become ambiguous.
llvm-svn: 368672

[CodeGen] Disable UBSan for coroutine functions
Summary: As explained in
http://lists.llvm.org/pipermail/llvm-dev/2018-March/121924.html, the
LLVM coroutines transforms are not yet able to move the instructions for
UBSan null checking past coroutine suspend boundaries. For now, disable
all UBSan checks when generating code for coroutines functions.
I also considered an approach where only '-fsanitize=null' would be
disabled, However in practice this led to other LLVM errors when writing
object files:
"Cannot represent a difference across sections". For now, disable all 
UBSan checks until coroutine transforms are updated to handle them.
Test Plan: 1. check-clang 2. Compile the program in
https://gist.github.com/modocache/54a036c3bf9c06882fe85122e105d153
  using the '-fsanitize=null' option and confirm it does not crash
  during LLVM IR generation.
Reviewers: GorNishanov, vsk, eric_niebler, lewissbaker
Reviewed By: vsk
Subscribers: cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D44672
llvm-svn: 368675

[llvm-readobj] - Remove 'error(Error EC)' helper.
We do not need it. I replaced it with reportError(StringRef Input, Error
Err).
Differential revision: https://reviews.llvm.org/D66011
llvm-svn: 368677

[lldb][NFC] Add basic IOHandler completion test
We have no test coverage for the IOHandler code that is doing the 
completion in the command line. This is adding a pexpect-based test as a
preparation for the switch to using CompletionRequest in the whole
completion machinery.
llvm-svn: 368679

[libTooling] In Transformer, generalize `applyFirst` to admit rules with
incompatible matchers.
Summary: This patch removes an (artificial) limitation of `applyFirst`,
which requires that all of the rules' matchers can be grouped together
in a single `anyOf()`. This change generalizes the code to group the
matchers into separate `anyOf`s based on compatibility. Correspondingly,
`buildMatcher` is changed to
`buildMatchers`, to allow for returning a set of matchers rather than
just one.
Reviewers: gribozavr
Subscribers: cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D65877
llvm-svn: 368681

[pstl] Allow customizing whether per-TU insulation is provided
Like we do in libc++, PSTL needs the ability to constrain ABI-unstable
symbols to each translation unit. This is OFF by default (like for
libc++), because most people don't care about this and there is a cost
associated to enabling the option (code bloat because templates are not
deduped across TUs).
I'm using '#pragma clang attribute push' to avoid marking each 
declaration with an attribute, which quickly becomes difficult to
maintain.
llvm-svn: 368684

[InstCombine] foldXorOfICmps(): don't give up on non-single-use ICmp's
if all users are freely invertible
Summary: This is rather unconventional..
As the comment there says, we don't have much folds for xor-of-icmps, we
try to turn them into an and-of-icmps, for which we have plenty of
folds. But if the ICmp we need to invert is not single-use - we give up.
As discussed in https://reviews.llvm.org/D65148#1603922, we may have a
non-canonical CLAMP pattern, with bit match and select-of-threshold that
we'll potentially clamp. As it can be seen in
`canonicalize-clamp-with-select-of-constant-threshold-pattern.ll`, out
of all 8 variations of the pattern, only two are **not** canonicalized
into the variant with and+icmp instead of bit math. The reason is
because the ICmp we need to invert is not single-use - we give up.
We indeed can't perform this fold at will, the general rule is that we
should not increase instruction count in InstCombine,
But we wouldn't end up increasing instruction count if we can adapt
every other user to the inverted value. This way the `not` we create
**will** get folded, and in the end the instruction count did not
increase.
For that, of course, we need to look at the users of a Value, which is
again rather unconventional for InstCombine :S
Thus i'm proposing to be a little bit more insistive in
`foldXorOfICmps()`. The alternatives would be to not create that `not`,
but add duplicate code to manually invert all users; or to add some even
less general combine to handle some more specific pattern[s].
Reviewers: spatel, nikic, RKSimon, craig.topper
Reviewed By: spatel
Subscribers: hiraditya, jdoerfert, dmgreen, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D65530
llvm-svn: 368685

[InstCombine][NFC] Rename IsFreeToInvert() -> isFreeToInvert() for
consistency
As per https://reviews.llvm.org/D65530#inline-592325
llvm-svn: 368686

[InstCombine] Non-canonical clamp-like pattern handling
Summary: Given a pattern like:
```
%old_cmp1 = icmp slt i32 %x, C2
%old_replacement = select i1 %old_cmp1, i32 %target_low, i32
%target_high
%old_x_offseted = add i32 %x, C1
%old_cmp0 = icmp ult i32 %old_x_offseted, C0
%r = select i1 %old_cmp0, i32 %x, i32 %old_replacement
``` it can be rewritten as more canonical pattern:
```
%new_cmp1 = icmp slt i32 %x, -C1
%new_cmp2 = icmp sge i32 %x, C0-C1
%new_clamped_low = select i1 %new_cmp1, i32 %target_low, i32 %x
%r = select i1 %new_cmp2, i32 %target_high, i32 %new_clamped_low
``` Iff `-C1 s<= C2 s<= C0-C1` Also, `ULT` predicate can also be `UGE`;
or `UGT` iff `C0 != -1` (+invert result) Also, `SLT` predicate can also
be `SGE`; or `SGT` iff `C2 != INT_MAX` (+invert result)
If `C1 == 0`, then all 3 instructions must be one-use; else at most
either `%old_cmp1` or `%old_x_offseted` can have extra uses. NOTE: if we
could reuse `%old_cmp1` as one of the comparisons we'll have to build,
this could be less limiting.
So there are two icmp's, each one with 3 predicate variants, so there
are 9 fold variants:
|     | ULT                            | UGE                            
| UGT                             |
| SLT | https://rise4fun.com/Alive/yIJ | https://rise4fun.com/Alive/5BfN
| https://rise4fun.com/Alive/INH  |
| SGE | https://rise4fun.com/Alive/hd8 | https://rise4fun.com/Alive/Abk 
| https://rise4fun.com/Alive/PlzS |
| SGT | https://rise4fun.com/Alive/VYG | https://rise4fun.com/Alive/oMY 
| https://rise4fun.com/Alive/KrzC |
{F9730206}
This fold was brought up in https://reviews.llvm.org/D65148#1603922 by
@dmgreen, and is needed to unblock that patch. This patch requires
D65530.
Reviewers: spatel, nikic, xbolva00, dmgreen
Reviewed By: spatel
Subscribers: hiraditya, llvm-commits, dmgreen
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D65765
llvm-svn: 368687

[lldb] Reland "Refactor guard variable checks in IRForTarget"
It seems the broken guard variable check for Windows was a feature(TM) 
and not a bug, so let's keep add a flag to the guard check that keeps 
the old behavior in the places where we ignored guard variables before.
llvm-svn: 368688

[analyzer][NFC] Refactoring BugReporter.cpp P1.: Store interesting
symbols/regions in a simple set
The goal of this refactoring effort was to better understand how
interestingness was propagated in BugReporter.cpp, which eventually
turned out to be a dead end, but with such a twist, I wouldn't even want
to spoil it ahead of time. However, I did get to learn a lot about how
things are working in there.
In these series of patches, as well as cleaning up the code big time, I
invite you to study how BugReporter.cpp operates, and discuss how we
could design this file to reduce the horrible mess that it is.
This patch reverts a great part of rC162028, which holds the title
"Allow multiple PathDiagnosticConsumers to be used with a BugReporter at
the same time.". This, however doesn't imply that there's any need for
multiple "layers" or stacks of interesting symbols and regions, quite
the contrary, I would argue that we would like to generate the same
amount of information for all output types, and only process them
differently.
Differential Revision: https://reviews.llvm.org/D65378
llvm-svn: 368689

[AIX][test/Index] Set/propagate AIXTHREAD_STK for AIX
Summary: Some tests perform deep recursion, which requires a larger
pthread stack size than the relatively low default of 192 KiB for 64-bit
processes on AIX. The `AIXTHREAD_STK` environment variable provides a
non-intrusive way to request a larger pthread stack size for the tests.
The required pthread stack size depends on the build configuration.
A 4 MiB default is generous compared to the 512 KiB of macOS; however, 
it is known that some compilers on AIX produce code that uses 
comparatively more stack space.
Reviewers: xingxue, daltenty, jasonliu
Reviewed By: daltenty
Subscribers: arphaman, jfb, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D65688
llvm-svn: 368690

[AIX] Implement LR prolog/epilog save/restore
Summary: This patch fixes the offsets of fields in the stack frame
linkage save area for AIX.
Reviewers: sfertile, hubert.reinterpretcast, jasonliu, Xiangling_L,
xingxue, ZarkoCA, daltenty
Reviewed By: hubert.reinterpretcast
Subscribers: wuzish, nemanjai, hiraditya, kbarton, MaskRay, jsji,
llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D64424
Patch by Chris Bowler!
llvm-svn: 368691

Fix -Wdocumentation typo. NFCI.
llvm-svn: 368692

Fix -Wdocumentation warning (@returns used in void function). NFCI.
llvm-svn: 368693

[analyzer][NFC] Refactoring BugReporter.cpp P2.: Clean up the
construction of bug paths and finding a valid report
This patch refactors the utility functions and classes around the
construction of a bug path.
At a very high level, this consists of 3 steps:
* For all BugReports in the same BugReportEquivClass, collect all their
error nodes in a set. With that set, create a new, trimmed ExplodedGraph
whose leafs are all error nodes.
* Until a valid report is found, construct a bug path, which is yet
another ExplodedGraph, that is linear from a given error node to the
root of the graph.
* Run all visitors on the constructed bug path. If in this process the
report got invalidated, start over from step 2.
Now, to the changes within this patch:
* Do not allow the invalidation of BugReports up to the point where the
trimmed graph is constructed. Checkers shouldn't add bug reports that
are known to be invalid, and should use visitors and argue about the
entirety of the bug path if needed.
* Do not calculate indices. I may be biased, but I personally find code
like this horrible. I'd like to point you to one of the comments in the
original code:
SmallVector<const ExplodedNode *, 32> errorNodes; for (const auto I :
bugReports) {
 if (I->isValid()) {
   HasValid = true;
   errorNodes.push_back(I->getErrorNode());
 } else {
   // Keep the errorNodes list in sync with the bugReports list.
   errorNodes.push_back(nullptr);
 }
}
Not on my watch. Instead, use a far easier to follow trick: store a
pointer to the BugReport in question, not an index to it.
* Add range iterators to ExplodedGraph's successors and predecessors,
and a visitor range to BugReporter.
* Rename TrimmedGraph to BugPathGetter. Because that is what it has
always been: no sane graph type should store an iterator-like state, or
have an interface not exposing a single graph-like functionalities.
* Rename ReportGraph to BugPathInfo, because it is only a linear path
with some other context.
* Instead of having both and out and in parameter (which I think isn't
ever excusable unless we use the out-param for caching), return a record
object with descriptive getter methods.
* Where descriptive names weren't sufficient, compliment the code with
comments.
Differential Revision: https://reviews.llvm.org/D65379
llvm-svn: 368694

[lldb] Fix Microsoft guard variable detection
Apparently we need to check for a suffix, not a prefix. This broke 
probably broke expression evaluation on Windows.
llvm-svn: 368695

[AArch64] Make the memtag sanitizer require the memtag extension
... or otherwise we get an ICE.
Differential Revision: https://reviews.llvm.org/D65508
llvm-svn: 368696

Enable memtag sanitizer in all AArch64 toolchains
That sanitizer does not have runtime library or other dependencies.
Differential Revision: https://reviews.llvm.org/D65642
llvm-svn: 368697

[llvm-readelf] Implement note parsing for NT_FILE and unknown
descriptors
Summary: This patch implements two note parsers; one for NT_FILE
coredumps, e.g.:
```
 CORE                  0x00000080      NT_FILE (mapped files)
   Page size: 4096
                Start                 End         Page Offset
   0x0000000000001000  0x0000000000002000  0x0000000000003000
       /path/to/a.out
   0x0000000000004000  0x0000000000005000  0x0000000000006000
       /path/to/libc.so
   0x0000000000007000  0x0000000000008000  0x0000000000009000
       [stack]
```
(A more realistic example can be tested locally by creating a crashing
program and running `llvm-readelf -n core`)
And also implements a raw hex dump for unknown descriptor data for
unhandled descriptor types.
Reviewers: MaskRay, jhenderson, grimar, alexshap
Reviewed By: MaskRay, grimar
Subscribers: emaste, llvm-commits, labath
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D65832
llvm-svn: 368698

Revert r368691; test checked in without changes by accident
llvm-svn: 368699

[clang-tidy] Update `TransformerClangTidyCheck` to use new
`buildMatchers` functionality.
Summary:
`buildMatchers` is the new, more general way to extract the matcher from
a rule. This change migrates the code to use it instead of
`buildMatcher`.
Reviewers: gribozavr
Subscribers: xazax.hun, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D65879
llvm-svn: 368700

[TargetLowering][NFC] prepareUREMEqFold(): fixup comment
The comment initially matched the code, but the code was incorrect and
was fixed after the initial revert back back when it was introduced, but
the comment was never updated.
llvm-svn: 368701

[CodeGen][SelectionDAG] More efficient code for X % C == 0 (SREM case)
Summary: This implements an optimization described in Hacker's Delight
10-17: when `C` is constant, the result of `X % C == 0` can be computed 
more cheaply without actually calculating the remainder. The motivation
is discussed here: https://bugs.llvm.org/show_bug.cgi?id=35479.
One huge caveat: this signed case is only valid for positive divisors.
While we can freely negate negative divisors, we can't negate `INT_MIN`, 
so for now if `INT_MIN` is encountered, we bailout. As a follow-up, it
should be possible to handle that more gracefully via extra
`and`+`setcc`+`select`.
This passes llvm's test-suite, and from cursory(!) cross-examination the
folds (the assembly) match those of GCC, and manual checking via alive 
did not reveal any issues (other than the `INT_MIN` case)
Reviewers: RKSimon, spatel, hermord, craig.topper, xbolva00
Reviewed By: RKSimon, xbolva00
Subscribers: xbolva00, thakis, javed.absar, hiraditya, dexonsmith,
llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D65366
llvm-svn: 368702

[libc++] Always build with -fvisibility=hidden
Summary: This avoids symbols being accidentally exported from the dylib
when they shouldn't. The next step is to use a pragma to apply hidden
visibility to all declarations (unless otherwise specified), which will
allow us to drop the per-declaration hidden visibility attributes we
currently have.
This also has the nice side effect of making sure the dylib exports the 
same symbols regardless of the optimization level.
PR38138
Reviewers: EricWF, mclow.lists
Subscribers: mgorny, christof, jkorous, dexonsmith, libcxx-commits
Tags: #libc
Differential Revision: https://reviews.llvm.org/D62868
llvm-svn: 368703

GlobalISel: Change representation of shuffle masks
Currently shufflemasks get emitted as any other constant, and you end up
with a bunch of virtual registers of G_CONSTANT with a G_BUILD_VECTOR.
The AArch64 selector then asserts on anything that doesn't fit this
pattern. This isn't an ideal representation, and should avoid
legalization and have fewer opportunities for a representational error.
Rather than invent a new shuffle mask operand type, similar to what 
ShuffleVectorSDNode does, just track the original IR Constant mask 
operand. I don't completely like the idea of adding another link to the
IR, but MIR is already quite dependent on IR constants already, and this
will allow sharing the shuffle mask utility functions with the IR.
llvm-svn: 368704

GlobalISel: Add more verifier checks for G_SHUFFLE_VECTOR
llvm-svn: 368705

Fix crash on switch conditions of non-integer types in templates
Clang currently crashes for switch statements inside a template when the
condition is a non-integer field. The crash is due to incorrect 
type-dependency of field. Type-dependency of member expressions is 
currently set based on the containing class. This patch changes this for
'members of the current instantiation' to set the type dependency based 
on the member's type instead.
A few lit tests started to fail once I applied this patch because errors 
are now diagnosed earlier (does not wait till instantiation). I've
modified these tests in this patch as well.
Patch fixes PR#40982
Differential Revision: https://reviews.llvm.org/D61027
llvm-svn: 368706

[ORC] Refactor definition-generation, add a generator for static
libraries.
This patch replaces the JITDylib::DefinitionGenerator typedef with a
class of the same name, and adds support for attaching a sequence of
DefinitionGeneration objects to a JITDylib.
This patch also adds a new definition generator, 
StaticLibraryDefinitionGenerator, that can be used to add symbols fom a
static library to a JITDylib. An object from the static library will be
added (via a supplied ObjectLayer reference) whenever a symbol from that
object is referenced.
To enable testing, lli is updated to add support for the --extra-archive
option when running in -jit-kind=orc-lazy mode.
llvm-svn: 368707

GlobalISel: Implement lower for G_SHUFFLE_VECTOR
llvm-svn: 368709

[lld][test] Update test to print ELF note description data
llvm-svn: 368710

[ARM] Fix encoding of APSR in CLRM instruction
The APSR is encoded by setting bit 15 in the register list of the CLRM 
instruction (cf.
https://static.docs.arm.com/ddi0553/bh/DDI0553B_h_armv8m_arm.pdf).
Differential Revision: https://reviews.llvm.org/D65873
llvm-svn: 368711

[ARM] Fix detection of duplicates when parsing reg list operands
Differential Revision: https://reviews.llvm.org/D65957
llvm-svn: 368712

GlobalISel: Partially implement fewerElementsVector G_UNMERGE_VALUES
Odd sized vectors aren't handled yet.
llvm-svn: 368713

[SLC] Improve dereferenceable bytes annotation
llvm-svn: 368715

[X86] Add some vXi8 extract subvector cost model tests
We don't have full 512-bit test coverage yet - but there's enough to
help test D65892
llvm-svn: 368716

[analyzer][NFC] Refactoring BugReporter.cpp P3.:
std::shared_pointer<PathDiagnosticPiece> -> PathDiagnosticPieceRef
find clang/ -type f -exec sed -i
's/std::shared_ptr<PathDiagnosticPiece>/PathDiagnosticPieceRef/g' {} \; 
git diff -U3 --no-color HEAD^ | clang-format-diff-6.0 -p1 -i
Just as C++ is meant to be refactored, right?
Differential Revision: https://reviews.llvm.org/D65381
llvm-svn: 368717

[Dwarf] Complete the list of type tags.
An incorrect verification error revealed that the list of type tags was 
incomplete. This patch adds the missing types by adding a tag kind to 
the Dwarf.def file, which is used by the `isType` function.
A test was added for the original verification error.
Differential revision: https://reviews.llvm.org/D65914
llvm-svn: 368718

[lld][WebAssembly] Allow linking of pic code into static binaries
Summary: See https://github.com/emscripten-core/emscripten/issues/9013
Subscribers: dschuff, jgravelle-google, aheejin, sunfish, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D65922
llvm-svn: 368719

[NFC][AIX] Use assert instead of llvm_unreachable
Addresses post-commit comments on https://reviews.llvm.org/D64825. Use 
assert instead of llvm_unreachable to check if invalid csect types are
being generated. Use report_fatal_error on unimplemented XCOFF features.
Differential Revision: https://reviews.llvm.org/D64825
llvm-svn: 368720

Reland r368691: "[AIX] Implement LR prolog/epilog save/restore"
Trying again with the code changes (and not just the new test).
Summary: This patch fixes the offsets of fields in the stack frame
linkage save area for AIX.
Reviewers: sfertile, hubert.reinterpretcast, jasonliu, Xiangling_L,
xingxue, ZarkoCA, daltenty
Reviewed By: hubert.reinterpretcast
Subscribers: wuzish, nemanjai, hiraditya, kbarton, MaskRay, jsji,
llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D64424
Patch by Chris Bowler!
llvm-svn: 368721

[NFC] Revisited/updated tests
llvm-svn: 368722

[ValueTracking] Improve reverse assumption inference
Use isGuaranteedToTransferExecutionToSuccessor() instead of 
isSafeToSpeculativelyExecute() when seeing whether we can propagate the
information in an assume backwards in isValidAssumeForContext(). The
latter is more general - it also allows arbitrary loads/stores - and is
also the condition we want: if our assume is guaranteed to execute, its
condition not holding would be UB.
Original patch by arielb1.
Differential Revision: https://reviews.llvm.org/D37215
llvm-svn: 368723

[SimplifyLibCalls] Add noalias from known callsites
Summary: Should be fine for memcpy, strcpy, strncpy.
 Reviewers: jdoerfert, efriedma
Reviewed By: jdoerfert
Subscribers: uenoku, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D66135
llvm-svn: 368724

[NFC] Updated tests after r368724
llvm-svn: 368725

[util] Allow callsigns when running git llvm revert
llvm-svn: 368726

Use Register over unsigned in LateEHPrepare (NFC)
Summary: While D65962 is pending for review, I landed D65475 that added
one more use of `unsigned`. Changed it to `Register`.
Reviewers: dsanders
Subscribers: dschuff, sbc100, jgravelle-google, hiraditya, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D66064
llvm-svn: 368727

clang: Don't warn on unused momit-leaf-frame-pointer when frame pointers
are off.
This fixes a regression from r365860: As that commit message states,
there are 3 valid states targeted by the combination of
-f(no-)omit-frame-pointer and -m(no-)omit-leaf-frame-pointer.
After r365860 it's impossible to get from state 10 (omit just leaf frame
pointers) to state 11 (omit all frame pointers) in a single command line
without getting a warning.
This change restores that functionality.
Fixes PR42966.
Differential Revision: https://reviews.llvm.org/D66142
llvm-svn: 368728

[NFC] Fixed test
llvm-svn: 368729

[AutoUpgrader] Make ArcRuntime Autoupgrader more conservative
Summary: This is a tweak to r368311 and r368646 which auto upgrades the
calls to objc runtime functions to objc runtime intrinsics, in order to
make sure that the auto upgrader does not trigger with up-to-date
bitcode.
It is possible for bitcode that is up-to-date to contain direct calls to 
objc runtime function and those are not inserted by compiler as part of 
ARC and they should not be upgraded. Now auto upgrader only triggers as 
when the old style of ARC marker is used so it is guaranteed that it 
won't trigger on update-to-date bitcode.
This also means it won't do this upgrade for bitcode from llvm-8 and 
llvm-9, which preserves the behavior of those releases. Ideally they 
should be upgraded as well but it is more important to make sure 
AutoUpgrader will not trigger on up-to-date bitcode.
Reviewers: ahatanak, rjmccall, dexonsmith, pete
Reviewed By: dexonsmith
Subscribers: hiraditya, jkorous, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D66153
llvm-svn: 368730

[llvm-profdata] Profile dump for compact binary format
Summary: Fix "llvm-profdata show" so it can work with compact binary
format profile. The change is to mark all functions "used" so
SampleProfileReaderCompactBinary::read will read in all profiles
available for dumping. The function names will be MD5 hash for compact
binary format.
Reviewers: wmi, davidxl, danielcdh
Subscribers: hiraditya, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D65162
llvm-svn: 368731

[clang] Refactor doc comments to Decls attribution
- Create ASTContext::attachCommentsToJustParsedDecls so we don't have to
load external comments in Sema when trying to attach existing comments
to just parsed Decls.
- Keep comments ordered and cache their decomposed location - faster
SourceLoc-based searching.
- Optimize work with redeclarations.
- Keep one comment per redeclaration chain (represented by canonical
Decl) instead of comment per redeclaration.
- For redeclaration chains with no comment attached keep just the last
declaration in chain that had no comment instead of every comment-less
redeclaration.
Differential Revision: https://reviews.llvm.org/D65301
llvm-svn: 368732

[ARM] Add MVE beats vector cost model
The MVE architecture has the idea of "beats", where a vector instruction
can be executed over several ticks of the architecture. This adds a
similar system into the Arm backend cost model, multiplying the cost of
all vector instructions by a factor.
This factor essentially becomes the expected difference between scalar
code and vector code, on average. MVE Vector instructions can also
overlap so the a true cost of them is often lower. But equally scalar
instructions can in some situations be dual issued, or have other
optimisations such as unrolling or make use of dsp instructions. The
default is chosen as 2. This should not prevent vectorisation is a most
cases (as the vector instructions will still be doing at least 4 times
the work), but it will help prevent over vectorising in cases where the
benefits are less likely.
This adds things so far to the obvious places in ARMTargetTransformInfo,
and updates a few related costs like not treating float instructions as
cost 2 just because they are floats.
Differential Revision: https://reviews.llvm.org/D66005
llvm-svn: 368733

[NFC][clang] Adding argument based Phase list filtering to
getComplicationPhases
This patch removes usage of FinalPhase from anywhere outside of the
scope where it is used to do argument handling.  It also adds argument
based trimming of the Phase list pulled out of the Types.def table.
Differential Revision: https://reviews.llvm.org/D65993
llvm-svn: 368734

[analyzer][NFC] Refactoring BugReporter.cpp P4.: If it can be const,
make it const
When I'm new to a file/codebase, I personally find C++'s strong static
type system to be a great aid. BugReporter.cpp is still painful to read
however: function calls are made with mile long parameter lists,
seemingly all of them taken with a non-const reference/pointer. This
patch fixes nothing but this: make a few things const, and hammer it
until it compiles.
Differential Revision: https://reviews.llvm.org/D65382
llvm-svn: 368735

[AMDGPU] Fix to 'Fold readlane from copy of SGPR or imm'
That change (r363670) could leave a copy from vgpr to sgpr. Fixed.
Differential Revision: https://reviews.llvm.org/D66133
Change-Id: I00c3fe6fda2e8e1e36f53195b881b1449c777ea4 llvm-svn: 368736

[analyzer][NFC] Refactoring BugReporter.cpp P5.: Compact mile long
function invocations into objects
In D65379, I briefly described the construction of bug paths from an 
ExplodedGraph. This patch is about refactoring the code processing the
bug path into a bug report.
A part of finding a valid bug report was running all visitors on the bug
path, so we already have a (possibly empty) set of diagnostics for each
ExplodedNode in it. Then, for each diagnostic consumer, we construct
non-visitor diagnostic pieces.
* We first construct the final diagnostic piece (the warning), then
* We start ascending the bug path from the error node's predecessor
(since the error node itself was used to construct the warning event).
For each node
 * We check the location (whether its a CallEnter, CallExit) etc. We
simultaneously
 keep track of where we are with the execution by pushing CallStack when
we see a
 CallExit (keep in mind that everything is happening in reverse!),
popping it
 when we find a CallEnter, compacting them into a single
PathDiagnosticCallEvent.
void f() {
 bar();
}
void g() {
 f();
 error(); // warning
}
=== The bug path ===
(root) -> f's CallEnter -> bar() -> f's CallExit -> (error node)
=== Constructed report ===
  f's CallEnter -> bar() -> f's CallExit
          ^               /
           \             V
(root) --->  f's CallEvent --> (error node)
  * We also keep track of different PathPieces different location
contexts
 * (CallEvent::path in the above example has f's LocationContext, while
the
 CallEvent itself is in g's context) in a LocationContextMap object.
Construct
 whatever piece, if any, is needed for the note.
 * If we need to generate edges (or arrows) do so. Make sure to also
connect
 these pieces with the ones that visitors emitted.
 * Clean up the constructed PathDiagnostic by making arrows nicer,
pruning
 function calls, etc.
So I complained about mile long function invocations with seemingly the
same parameters being passed around. This problem, as I see it, a
natural candidate for creating classes and tying them all together.
I tried very hard to make the implementation feel natural, like, rolling
off the tongue. I introduced 2 new classes: PathDiagnosticBuilder (I
mean, I kept the name but changed almost everything in it) contains
every contextual information
(owns the bug path, the diagnostics constructed but the visitors, the
BugReport itself, etc) needed for constructing a PathDiagnostic object,
and is pretty much completely immutable. BugReportContruct is the object
containing every non-contextual information (the PathDiagnostic object
we're constructing, the current location in the bug path, the location
context map and the call stack I meantioned earlier), and is passed
around all over the place as a single entity instead of who knows how
many parameters.
I tried to used constness, asserts, limiting visibility of fields to my 
advantage to clean up the code big time and dramatically improve safety.
Also, whenever I found the code difficult to understand, I added
comments and/or examples.
Here's a complete list of changes and my design philosophy behind it:
* Instead of construcing a ReportInfo object (added by D65379) after
finding a valid bug report, simply return an optional
PathDiagnosticBuilder object straight away. Move findValidReport into
the class as a static method. I find 
GRBugReporter::generatePathDiagnostics a joy to look at now.
* Rename generatePathDiagnosticForConsumer to generate (maybe not
needed, but felt that way in the moment) and moved it to
PathDiagnosticBuilder. If we don't need to generate diagnostics, bail
out straight away, like we always should have. After that, construct a
BugReportConstruct object, leaving the rest of the logic untouched.
* Move all static methods that would use contextual information into 
PathDiagnosticBuilder, reduce their parameter count drastically by
simply passing around a BugReportConstruct object.
* Glance at the code I removed: Could you tell what the original 
PathDiagnosticBuilder::LC object was for? It took a gooood long while
for me to realize that nothing really. It is always equal with the
LocationContext associated with our current position in the bug path.
Remove it completely.
* The original code contains the following expression quite a bit: 
LCM[&PD.getActivePath()], so what does it mean? I said that we collect
the contexts associated with different PathPieces, but why would we ever
modify that, shouldn't it be set? Well, theoretically yes, but in the
implementation, the address of PathDiagnostic::getActivePath doesn't
change if we move to an outer, previously unexplored function. Add both
descriptive method names and explanations to BugReportConstruct to help
on this.
* Add plenty of asserts, both for safety and as a poor man's
documentation.
Differential Revision: https://reviews.llvm.org/D65484
llvm-svn: 368737

Revert "Fix crash on switch conditions of non-integer types in
templates"
This reverts commit r368706. It broke ClangTidy tests.
llvm-svn: 368738

Don't use std::errc
Summary: As noted on Errc.h:
// * std::errc is just marked with is_error_condition_enum. This means
that
//   common patters like AnErrorCode == errc::no_such_file_or_directory
take
//   4 virtual calls instead of two comparisons.
And on some libstdc++ those virtual functions conclude that
------------------------ int main() {
 std::error_code foo =
std::make_error_code(std::errc::no_such_file_or_directory);
 return foo == std::errc::no_such_file_or_directory;
}
-------------------------
should exit with 0.
Reviewers: thakis, rnk, jfb
Reviewed By: thakis
Subscribers: lebedev.ri, dexonsmith, xbolva00, cfe-commits, caomhin
Tags: #clang
Differential Revision: https://reviews.llvm.org/D66143
llvm-svn: 368739

[ORC] Fix BuildingAJIT tutorial code broken by r368707.
llvm-svn: 368740

[Symbol] Decouple clang from CompilerType
Summary: Ideally CompilerType would have no knowledge of clang or any
individual TypeSystem. Decoupling clang is relatively straightforward.
Differential Revision: https://reviews.llvm.org/D66102
llvm-svn: 368741

[DWARF} Use LLVM's debug line parser in LLDB.
The line number table header was substantially revised in DWARF 5 and is 
not fully supported by LLDB's current debug line implementation.
This patch replaces the LLDB debug line parser with its counterpart in 
LLVM. This was possible because of the limited contact surface between 
the code to parse the DWARF debug line section and the rest of LLDB.
We pay a small cost in terms of performance and memory usage. This is 
something we plan to address in the near future.
Differential revision: https://reviews.llvm.org/D62570
llvm-svn: 368742

[Refactor] Moving SourceExtraction header from lib to include
Summary:
- Moved the SourceExtraction header from lib to include so that it can
be used in clangd.
Reviewers: arphaman
Subscribers: ilya-biryukov, dexonsmith, kadircet, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D65878
llvm-svn: 368743

    [AIX]Lowering global address for 32/64bit small/large code models
    This patch implements global address lowering for 32/64 bit with
small/large code models.
   1.For 32bit large code model on AIX, there are newly added pseudo
opcode LWZtocL & ADDIStocHA32, the support of which on MC layer will be
      provided by future patches.
   2.The default code model on AIX should be small code model.
   3.Since AIX does not have medium code model, "report_fatal_error"
when users specify it.
    Differential Revision: https://reviews.llvm.org/D63547
llvm-svn: 368744

[analyzer][NFC] Address inlines of D65484
llvm-svn: 368745

[DWARF] Guess the path style
Try to guess the FileSpec path style before defaulting to native.
llvm-svn: 368746

[GISel] Pass MachineRegisterInfo by const reference to matcher.
Summary: NFC.
Reviewers: aditya_nandakumar, volkan
Subscribers: llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D65971
llvm-svn: 368747

Remove the extra `;`.
llvm-svn: 368748

[libc++] Mark two <chrono> tests as unsupported on AppleClang 11
The operator""y and operator""d will eventually be supported by 
AppleClang, but no released version supports them at the moment.
llvm-svn: 368749

[WebAssembly] Make clang emit correct va_arg code for structs
Summary: In the WebAssembly backend, when lowering variadic function
calls, non-single member aggregate type arguments are always passed by
pointer.
However, when emitting va_arg code in clang, the arguments are instead
read as if they are passed directly. This results in the pointer being
read as the actual structure.
Fixes https://github.com/emscripten-core/emscripten/issues/9042.
Reviewers: tlively, sbc100, kripken, aheejin, dschuff
Reviewed By: dschuff
Subscribers: dschuff, jgravelle-google, sunfish, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D66168
llvm-svn: 368750

Factor architecture dependent code out of loop.cu
Summary:
[libomptarget] Factor architecture dependent code out of loop.cu
Related to the patch series starting D64217. Added subscribers to said
series as reviewers. This effort is smaller in scope.
This patch factors out just enough architecture dependent code from
loop.cu to allow the same source to be used with amdgcn, given a
different target_impl.h. Testing is that the same bitcode (modulo
variable names) is generated for libomptarget before and after the
refactor, for nvptx and the out of tree amdgcn.
Reviewers: jdoerfert, ABataev, bollu, jfb, tra, grokos, Hahnfeld,
guansong, xtian, gregrodgers, ronlieb, hfinkel, gtbercea, guraypp,
arpith-jacob
Reviewed By: jdoerfert, ABataev
Subscribers: dexonsmith, openmp-commits
Tags: #openmp
Differential Revision: https://reviews.llvm.org/D65836
llvm-svn: 368751

[analyzer][NFC] Refactoring BugReporter.cpp P6.: Completely get rid of
interestingness propagation
Apparently this does literally nothing.
When you think about this, it makes sense. If something is really
important, we're tracking it anyways, and that system is sophisticated
enough to mark actually interesting statements as such. I wouldn't say
that it's even likely that subexpressions are also interesting (array[10
- x + x]), so I guess even if this produced any effects, its probably
undesirable.
Differential Revision: https://reviews.llvm.org/D65487
llvm-svn: 368752

[GlobalISel]: Fix lowering of G_SHUFFLE_VECTOR with scalar sources
https://reviews.llvm.org/D66171
llvm-svn: 368753

Add a missing header comment, NFC
llvm-svn: 368754

[analyzer][NFC] Make sure that the BugReport is not modified during the
construction of non-visitor pieces
I feel this is kinda important, because in a followup patch I'm adding
different kinds of interestingness, and propagating the correct kind in
BugReporter.cpp is just one less thing to worry about.
Differential Revision: https://reviews.llvm.org/D65578
llvm-svn: 368755

Relax opcode checks in test to check for only a number instead of a
specific number.
llvm-svn: 368756

[GlobalISel][NFC] Factor out common target code from
GlobalISelEmitterTests
Factor out commonly-used target code from the GlobalISelEmitter tests
into a GlobalISelEmitterCommon.td file. This is tested by the original 
GlobalISelEmitter.td test.
This reduces the amount of boilerplate code necessary for tests like
this.
Differential Revision: https://reviews.llvm.org/D65777
llvm-svn: 368757

[NFCI] Explicitly provide user-defined constructor for SectionRef
I am changing this to work around an issue that is being hit when 
building with clang 3.8. Specifically, clang 3.8 requires that we have a
user defined default constructor for SectionRef for the default
initialization of a const SectionRef.
llvm-svn: 368758

Initial support for native debugging of x86/x64 Windows processes
Summary: Thanks to Hui Huang and the reviewers for all the help with
this patch.
Reviewers: labath, Hui, jfb, clayborg, amccarth
Reviewed By: labath
Subscribers: amccarth, compnerd, dexonsmith, mgorny, jfb, teemperor,
lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D63165
llvm-svn: 368759

Attempt to fix issue with unresolved lit test in TableGen
Build bots are unhappy about the Common directory.
Add an excludes list to lit.local.cfg.
llvm-svn: 368760

[clang] DirectoryWatcher for Windows stubs (to fix build break).
This is just a code skeleton for DirectoryWatcher-windows.cpp so the 
build on Windows stops breaking.
(upstreamed from github.com/apple/swift-clang)
llvm-svn: 368761

[clang][DirectoryWatcher] Fix Windows stub after LLVM change
r367979 changed DirectoryWatcher::Create to return an llvm::Expected. 
Adjust the Windows stub accordingly.
(upstreamed from github.com/apple/swift-clang)
llvm-svn: 368762

[Polly-ACC] Fix test after IR-printer change.
After r367755, even unnamed parameters are printed in IR dumps. Change 
the test to expect te additional %0 in the line.
llvm-svn: 368763

[ORC] Fix SpeculativeJIT example code broken by r368707.
llvm-svn: 368764

[analyzer] Disable the checker-plugins test on Darwin.
Fixes a buildbot.
llvm-svn: 368765

[analyzer] exploded-graph-rewriter: Open the converted graph
immediately.
Change the default behavior: the tool no longer dumps the rewritten .dot
file to stdout, but instead it automatically converts it into an .html
file
(which essentially wraps an .svg file) and immediately opens it with the
default web browser.
This means that the tool should now be fairly easy to use:
  $ exploded-graph-rewriter.py /tmp/ExprEngine.dot
The benefits of wrapping the .svg file into an .html file are:
    - It'll open in a web browser, which is the intended behavior.
     An .svg file would be open with an image viewer/editor instead.
   - It avoids the white background around the otherwise dark svg area
     in dark mode.
The feature can be turned off by passing a flag '--rewrite-only'. The
LIT substitution is updated to enforce the old mode because we don't
want web browsers opening on our buildbots.
Differential Revision: https://reviews.llvm.org/D65250
llvm-svn: 368766

[analyzer] exploded-graph-rewriter: NFC: Refactor explorers into
trimmers.
Explorers aren't the right abstraction. For the purposes of displaying
svg files we don't care in which order do we explore the nodes. We may
care about this for other analyses, but we're not there yet.
The function of cutting out chunks of the graph is performed poorly by 
the explorers, because querying predecessors/successors on the explored
nodes yields original successors/predecessors even if they aren't being
explored.
Introduce a new entity, "trimmers", that do one thing but to it right:
cut out chunks of the graph. Trimmers mutate the graph, so stale edges
aren't even visible to their consumers in the pipeline. Additionally,
trimmers are intrinsically composable: multiple trimmers can be applied
to the graph sequentially.
Refactor the single-path explorer into the single-path trimmer. Rename
the test file for consistency.
Differential Revision: https://reviews.llvm.org/D65344
llvm-svn: 368767

[analyzer] exploded-graph-rewriter: Implement manual graph trimming.
When -trim-egraph is unavailable (say, when you're debugging a crash on 
a real-world code that takes too long to reduce), it makes sense to view 
the untrimmed graph up to the crashing node's predecessor, then dump the
ID
(or a pointer) of the node in the attached debugger, and then trim the
dumped graph in order to keep only paths from the root to the node.
The newly added --to flag does exactly that:
$ exploded-graph-rewriter.py ExprEngine.dot --to 0x12229acd0
Multiple nodes can be specified. Stable IDs of nodes can be used instead
of pointers.
Differential Revision: https://reviews.llvm.org/D65345
llvm-svn: 368768

[analyzer] exploded-graph-rewriter: Implement displaying Store pointers.
They're useful when trying to understand what's going on inside your
LazyCompoundValues.
Differential Revision: https://reviews.llvm.org/D65427
llvm-svn: 368769

[AArch64] Remove incorrect usage of MONonTemporal.
This has no effect at the moment, but might matter if we try to 
implement non-temporal loads in the future.
llvm-svn: 368770

[analyzer] Prune calls to functions with linear CFGs that return a
non-zero constrained value
During the evaluation of D62883, I noticed a bunch of totally 
meaningless notes with the pattern of "Calling 'A'" -> "Returning value"
-> "Returning from 'A'", which added no value to the report at all.
This patch (not only affecting tracked conditions mind you) prunes 
diagnostic messages to functions that return a value not constrained to 
be 0, and are also linear.
Differential Revision: https://reviews.llvm.org/D64232
llvm-svn: 368771

[DebugLine] Be more robust in geussing the path style
My previous change didn't fix the Windows bot. This patch is an attempt 
to make guessing the path style more robust by first looking at the 
compile dir and falling back to the actual file if that's unsuccessful.
llvm-svn: 368772

[analyzer] Track the right hand side of the last store regardless of its
value
Summary: The following code snippet taken from D64271#1572188 has an
issue: namely, because `flag`'s value isn't undef or a concrete int, it
isn't being tracked.
int flag; bool coin();
void foo() {
 flag = coin();
}
void test() {
 int *x = 0;
 int local_flag;
 flag = 1;
  foo();
 local_flag = flag;
 if (local_flag)
   x = new int;
  foo();
 local_flag = flag;
 if (local_flag)
   *x = 5;
}
This, in my opinion, makes no sense, other values may be interesting
too. Originally added by rC185608.
Differential Revision: https://reviews.llvm.org/D64287
llvm-svn: 368773

Enable lldb-server on Windows
Summary: This commit contains three small changes to enable lldb-server
on Windows.
- Add lldb-server for Windows to the build
- Disable pty redirection on Windows for the initial lldb-server bring
up
- Add a support to get the parent pid for a process on Windows
- Ifdef some signals which aren't supported on Windows
Thanks to Hui Huang for the help with this patch!
Reviewers: labath
Reviewed By: labath
Subscribers: JDevlieghere, compnerd, Hui, amccarth, xiaobai, srhines,
mgorny, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D61686
llvm-svn: 368774

[AArch64][GlobalISel] RBS: Treat s128s like vectors when unmerging.
The destinations should be FPRs (for now).
Differential Revision: https://reviews.llvm.org/D66184
llvm-svn: 368775

Update Python tests for lldb-server on Windows
Summary: Thanks to Hui Huang and reviewers for all the help with this
patch!
Reviewers: labath, jfb, clayborg
Reviewed By: labath
Subscribers: Hui, clayborg, dexonsmith, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D61687
llvm-svn: 368776

[analyzer][NFC] Prepare visitors for different tracking kinds
When we're tracking a variable that is responsible for a null pointer 
dereference or some other sinister programming error, we of course would
like to gather as much information why we think that the variable has
that specific value as possible. However, the newly introduced condition
tracking shows that tracking all values this thoroughly could easily
cause an intolerable growth in the bug report's length.
There are a variety of heuristics we discussed on the mailing list[1] to
combat this, all of them requiring to differentiate in between tracking
a "regular value" and a "condition".
This patch introduces the new `bugreporter::TrackingKind` enum, adds it
to several visitors as a non-optional argument, and moves some functions
around to make the code a little more coherent.
[1] http://lists.llvm.org/pipermail/cfe-dev/2019-June/062613.html
Differential Revision: https://reviews.llvm.org/D64270
llvm-svn: 368777

[ORC] Fix clang-interpreter example code broken by r368707.
llvm-svn: 368778

[analyzer] Don't delete TaintConfig copy constructor
Summary: Explicitly deleting the copy constructor makes compiling the
function
`ento::registerGenericTaintChecker` difficult with some compilers. When
we construct an `llvm::Optional<TaintConfig>`, the optional is
constructed with a const TaintConfig reference which it then uses to
invoke the deleted TaintConfig copy constructor.
I've observered this failing with clang 3.8 on Ubuntu 16.04.
Reviewers: compnerd, Szelethus, boga95, NoQ, alexshap
Subscribers: xazax.hun, baloghadamsoftware, szepet, a.sidorin,
mikhail.ramalho, donat.nagy, dkrupp, Charusso, llvm-commits, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D66192
llvm-svn: 368779

[GlobalISel]: Fix lowering of G_Shuffle_vector where we pick up the
wrong source index
https://reviews.llvm.org/D66182
llvm-svn: 368781

Fix warning: suggest braces around initialization of subobject
This patch adds braces to the DEFINE_XMM macro.
llvm-svn: 368782

[libcxxabi] Define _LIBCXXABI_GUARD_ABI_ARM on WebAssembly
This matches ItaniumCXXABI.cpp.
Fixes PR42680
Differential Revision: https://reviews.llvm.org/D64961
llvm-svn: 368783

[ELF] Initialize 2 fields of Symbol in SymbolTable::insert
A new symbol is added to elf::symtab in 3 steps:
1) SymbolTable::insert creates a placeholder. 2) Symbol::mergeProperties 
3) Symbol::replace
Fields referenced by steps 2) and 3) should be initialized in 
SymbolTable::insert.  `traced` and `referenced` were missed previously. 
This did not cause problems because compilers generated code that 
initialized them (bit fields) to 0.
Reviewed By: grimar
Differential Revision: https://reviews.llvm.org/D66130
llvm-svn: 368784

Add __has_builtin support for builtin function-like type traits.
Summary: Previously __has_builtin(__builtin_*) would return false for
__builtin_*s that we modeled as keywords rather than as functions
(because they take type arguments). With this patch, all builtins that
are called with function-call-like syntax return true from
__has_builtin (covering __builtin_* and also the __is_* and __has_* type 
traits and the handful of similar builtins without such a prefix).
Update the documentation on __has_builtin and on type traits to match. 
While doing this I noticed the type trait documentation was out of date 
and incomplete; that's fixed here too.
Reviewers: aaron.ballman
Subscribers: jfb, kristina, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D66100
llvm-svn: 368785

[FileCheck] Move -dump-input diagnostic to first line
Without this patch, `-dump-input` prints a diagnostic at the end of its
marker range.  For example:
```
        1: Start. check:1     ^~~~~~
        2: Bad. next:2      X~~~
        3: Many lines next:2      ~~~~~~~~~~
        4: of input. next:2      ~~~~~~~~~
        5: End. next:2      ~~~~ error: no match found
```
This patch moves it to the beginning like this:
```
        1: Start. check:1     ^~~~~~
        2: Bad. next:2      X~~~ error: no match found
        3: Many lines next:2      ~~~~~~~~~~
        4: of input. next:2      ~~~~~~~~~
        5: End. next:2      ~~~~
```
The former somehow looks nicer because the diagnostic doesn't appear to
be somewhere within the marker range.  However, the latter is more 
practical, especially when the marker range includes the remainder of a
very long dump.  First, in the case of an error, this patch enables me
to search the dump for `error:` and usually immediately land where the
detected error began.  Second, when trying to follow FileCheck's logic,
it's best to read top down, so this patch enables me to see each
diagnostic as soon as I encounter its marker.
Reviewed By: thopre
Differential Revision: https://reviews.llvm.org/D65702
llvm-svn: 368786

[FileCheck] Document FILECHECK_OPTS in -help
Reviewed By: thopre
Differential Revision: https://reviews.llvm.org/D65707
llvm-svn: 368787

Extend coroutines to support a "returned continuation" lowering.
A quick contrast of this ABI with the currently-implemented ABI:
- Allocation is implicitly managed by the lowering passes, which is fine
 for frontends that are fine with assuming that allocation cannot fail.
 This assumption is necessary to implement dynamic allocas anyway.
- The lowering attempts to fit the coroutine frame into an opaque,
 statically-sized buffer before falling back on allocation; the same
 buffer must be provided to every resume point.  A buffer must be at
 least pointer-sized.
- The resume and destroy functions have been combined; the continuation
 function takes a parameter indicating whether it has succeeded.
- Conversely, every suspend point begins its own continuation function.
- The continuation function pointer is directly returned to the caller
 instead of being stored in the frame.  The continuation can therefore
 directly destroy the frame when exiting the coroutine instead of having
 to leave it in a defunct state.
- Other values can be returned directly to the caller instead of going
 through a promise allocation.  The frontend provides a "prototype"
 function declaration from which the type, calling convention, and
 attributes of the continuation functions are taken.
- On the caller side, the frontend can generate natural IR that directly
 uses the continuation functions as long as it prevents IPO with the
 coroutine until lowering has happened.  In combination with the point
 above, the frontend is almost totally in charge of the ABI of the
 coroutine.
- Unique-yield coroutines are given some special treatment.
llvm-svn: 368788

Generalize llvm.coro.suspend.retcon to allow an arbitrary number of
arguments to be passed back to the continuation function.
llvm-svn: 368789

Guard dumps in the coro intrinsic validation logic behind NDEBUG checks.
dump() is not guaranteed to be defined in all builds.
llvm-svn: 368790

Add intrinsics for doing frame-bound dynamic allocations within a
coroutine.
These rely on having an allocator provided to the coroutine and thus, 
for now, only work in retcon lowerings.
llvm-svn: 368791

Fix a use-after-free in the coro.alloca treatment.
llvm-svn: 368792

In coro.retcon lowering, don't explode if the optimizer messes around
with the linkage of the prototype or the exact types of the yielded
values.
llvm-svn: 368793

Update for optimizer changes.
rdar://37352868
llvm-svn: 368794

Support swifterror in coroutine lowering.
The support for swifterror allocas should work in all lowerings. The
support for swifterror arguments only really works in a lowering with
prototypes where you can ensure that the prototype also has a swifterror
argument; I'm not really sure how it could possibly be made to work in
the switch lowering.
llvm-svn: 368795

Remove unreachable blocks before splitting a coroutine.
The suspend-crossing algorithm is not correct in the presence of uses 
that cannot be reached on some successor path from their defs.
llvm-svn: 368796

Don't run a full verifier pass in coro-splitting's private pipeline.
Potentially addresses rdar://49022293.
llvm-svn: 368797

Coroutines: adjust for SVN r358739
CallSite has been removed in favour of CallBase.  Adjust the coroutine
split to account for that.
llvm-svn: 368798

Remove minimum toolchain soft-error
Summary: Back in January I changed the minimum toolchain version
required to build clang and LLVM: D57264. Since then we've release LLVM
8, following
[our process](http://llvm.org/docs/DeveloperPolicy.html#toolchain) it's
therefore now a good time to remove the soft-error and officially
deprecate older toolchains. I tried this out last Tursday night to see
if any bots complained, and I saw no complaints. I also manually audited
bots and didn't see any bot that should break, but their toolchain
information is unreliable and some bots are offline.
Once this patch stick we'll move to C++14 as we've
[already
agreed](http://lists.llvm.org/pipermail/llvm-dev/2019-January/129452.html).
Subscribers: mgorny, jkorous, dexonsmith, llvm-commits, EricWF, thakis,
chandlerc
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D66188
llvm-svn: 368799

Revert '[LICM] Make Loop ICM profile aware' and 'Fix pass dependency for
LICM'
This reverts r368526 (git commit
7e71aa24bc0788690fea7f0d7eab400c6a784deb) This reverts r368542 (git
commit cb5a90fd314a7914cf293797bb4fd7a6841052cf)
llvm-svn: 368800

[LV] Fold-tail flag
This is the compiler-flag equivalent of the Predicate pragma
(https://reviews.llvm.org/D65197), to direct the vectorizer to fold the 
remainder-loop into the main-loop using predication.
Differential Revision: https://reviews.llvm.org/D66108
Reviewers: Ayal, hsaito, fhahn, SjoerdMeije llvm-svn: 368801

[lldb] Reinstate original guard variable check
The isGuardVariableSymbol option for ignoring Microsoft's ABI was
originally added to get the bots green, but now that we found the actual
issue (that we checked for prefix instead of suffix in the MS ABI
check), we should be able to properly implement the guard variable check
without any strange Microsoft exceptions.
llvm-svn: 368802

[NewPM][PassInstrumentation] IR printing support from clang driver
Summary: https://reviews.llvm.org/D50923 enabled the IR printing support
for the new pass manager, but only for the case when `opt` tool is used
as a driver. This patch is to enable the IR printing when `clang` is
used as a driver.
Reviewers: fedor.sergeev, philip.pfaffe
Subscribers: cfe-commits, yamauchi, llvm-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D65975
llvm-svn: 368804

Removed dead code from clang/tools/libclang/CXIndexDataConsumer.{cpp,h}
Reviewers: jkorous
Subscribers: dexonsmith, arphaman, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D66156
llvm-svn: 368805

[API] Have SBCommandReturnObject::GetOutput/Error return "" instead of
nullptr
Summary: It seems this was an unintended side-effect of D26698. AFAICT,
these functions did return an empty string before that patch, and the
patch contained code which attempted to ensure that, but those efforts
were negated by ConstString::AsCString, which by default returns a
nullptr even for empty strings.
This patch:
- fixes the GetOutput/Error methods to really return empty strings
- adds and explicit test for that
- removes a workaround in lldbtest.py, which was masking this problem
 from our other tests
Reviewers: jingham, clayborg
Subscribers: zturner, lldb-commits
Differential Revision: https://reviews.llvm.org/D65739
llvm-svn: 368806

[InstCombine][NFC] Autogenerate checks in adjust-for-minmax.ll
Being affected by WIP patch.
llvm-svn: 368807

Fix the -Wunused-variable warning.
llvm-svn: 368808

[Codegen] Updated test for D66158
Reviewers: jdoerfert
Reviewed By: jdoerfert
Subscribers: cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D66173
llvm-svn: 368809

[Intrinsics] Add a 'NoAlias' intrinsic property; annotate llvm.memcpy
Reviewers: jdoerfert
Reviewed By: jdoerfert
Differential Revision: https://reviews.llvm.org/D66158
llvm-svn: 368810

[llvm-objdump] - Add a relocation-xindex-symbol.test test case.
This rewrites the exitent test case to use YAML instead of the
precompiled object and moves it from test/Object to an appropriate
llvm-objdump tests folder.
Differential revision: https://reviews.llvm.org/D66140
llvm-svn: 368811

[llvm/Object] - Convert SectionRef::getName() to return Expected<>
SectionRef::getName() returns std::error_code now. Returning Expected<>
instead has multiple benefits.
For example, it forces user to check the error returned. Also Expected<>
may keep a valuable string error message, what is more useful than
having a error code.
(Object\invalid.test was updated to show the new messages printed.)
This patch makes a change for all users to switch to Expected<> version.
Note: in a few places the error returned was ignored before my changes. 
In such places I left them ignored. My intention was to convert the
interface used, and not to improve and/or the existent users in this
patch.
(Though I think this is good idea for a follow-ups to revisit such
places and either remove consumeError calls or comment each of them to
clarify why it is OK to have them).
Differential revision: https://reviews.llvm.org/D66089
llvm-svn: 368812

Revert r368812 "[llvm/Object] - Convert SectionRef::getName() to return
Expected<>"
It broke clang BB:
http://lab.llvm.org:8011/builders/clang-x86_64-debian-fast/builds/16455
llvm-svn: 368813

[MinGW] Remove stray/inconsistent comment chars in test file. NFC.
Test directives don't need to be in comments in this file.
llvm-svn: 368814

[MinGW] Restructure Options.td to use multiclass where sensible. NFC.
Differential Revision: https://reviews.llvm.org/D66065
llvm-svn: 368815

[MinGW] Correct handling different forms of a few options
Support the equals form of the long --entry=<symbol> option, add a test
for the -e<symbol> form.
Add tests for single dash forms of -exclude-all-symbols and
-export-all-symbols.
Support single-dash forms of -out-implib and -output-def, support the
equals form of --output-def=<file>. (We previously had a test to
explicitly disallow -out-implib, but it turns out that GNU ld actually
does support it just fine, despite also matching the
-o<file> option.)
Disallow the double-dashed --u form, add a test for -u<symbol>.
Differential Revision: https://reviews.llvm.org/D66066
llvm-svn: 368816

[analyzer] Note last writes to a condition only in a nested stackframe
Exactly what it says on the tin! The comments in the code detail this a 
little more too.
Differential Revision: https://reviews.llvm.org/D64272
llvm-svn: 368817

[ASTImporter] Import default expression of param before creating the
param.
Summary: The default expression of a parameter variable should be
imported before the parameter variable object is created. Otherwise the
function is created with an incomplete parameter variable (default
argument is nullptr) and in this intermediary state the expression is
imported. This import can have a reference to the incomplete parameter
variable that causes crash.
Reviewers: martong, a.sidorin, shafik
Reviewed By: martong
Subscribers: rnkovacs, dkrupp, Szelethus, gamesh411, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D65577
llvm-svn: 368818

[InstCombine] Refactor getFlippedStrictnessPredicateAndConstant() out of
canonicalizeCmpWithConstant(), NFCI
I'd like to use it elsewhere, hopefully without reinventing the wheel. 
No functional change intended so far.
llvm-svn: 368820

[llvm-size][test] Improve llvm-size testing
This patch significantly improves the llvm-size testing. The changes 
made are:
1) Change all tests to use yaml2obj instead of assembly or pre-canned
  inputs. 2) Move the tests out of the X86 directory, since they don't
need to be
  there after 1). 3) Increased test coverage. 4) Added comments to
explain purpose of tests.
I haven't attempted to add test coverage for all Mach-O related code, as 
I am not familiar enough with that file format to be able to.
Reviewers: grimar, MaskRay
Differential Revision: https://reviews.llvm.org/D66134
llvm-svn: 368821

Fix _WIN32 / _WIN64 Wundef warnings
For these macros it is the definedness that matters rather than the
value.  Make new uses of these macros consistent with existing uses.
llvm-svn: 368822

[AsmPrinter] Delete redundant .type foo, @function when emitting an
ifunc
In MCAsmStreamer:
.type foo,@function   # <--- this is redundant
.type foo,@gnu_indirect_function
In MCELFStreamer, the latter STT_GNU_IFUNC overrides STT_FUNC.
llvm-svn: 368823

[clangd] Fix typos and grammar in a comment. NFC
llvm-svn: 368824

[clang] - An update after LLVM change.
SectionRef::getName() was changed to return Expected<> (D66089)
llvm-svn: 368825

Recommit r368812 "[llvm/Object] - Convert SectionRef::getName() to
return Expected<>"
Changes: no changes. A fix for the clang code will be landed right on
top.
Original commit message:
SectionRef::getName() returns std::error_code now. Returning Expected<>
instead has multiple benefits.
For example, it forces user to check the error returned. Also Expected<>
may keep a valuable string error message, what is more useful than
having a error code.
(Object\invalid.test was updated to show the new messages printed.)
This patch makes a change for all users to switch to Expected<> version.
Note: in a few places the error returned was ignored before my changes. 
In such places I left them ignored. My intention was to convert the
interface used, and not to improve and/or the existent users in this
patch.
(Though I think this is good idea for a follow-ups to revisit such
places and either remove consumeError calls or comment each of them to
clarify why it is OK to have them).
Differential revision: https://reviews.llvm.org/D66089
llvm-svn: 368826

Improved the doc comment for getCommentsInFile
Subscribers: cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D66209
llvm-svn: 368827