LLVM and SPIRV-LLVM-Translator pulldown (WW35) #2362

The getSrcFromCopy helper nowadays return a MachineOperand pointer, so talking about zero_reg was incorrect as it nowadays return a nullptr when not finding a copy like instruction.

This was accidentally added in 53b9199 Differential Revision: https://reviews.llvm.org/D86284

Currently, clangd crashes when opening a file with `#pragma clang __debug parser_crash` (e.g. clang/test/Modules/Inputs/crash.h). This patch disables these crashes. Reviewed By: kadircet Differential Revision: https://reviews.llvm.org/D86279

…n-clang-tidy.py The action='store_true' option of argparse.add_argument implicitly generates a default value of False if the argument is not specified. Thus, the allow_enabling_alpha_checkers argument of get_tidy_invocation is never None.

This is very similar to D85968, only more elusive to since we were not adding the typedef type to the relevant DeclContext until D86140, which meant that the DeclContext was populated (and the relevant assertion hit) only after importing the type into the expression ast in a particular way. I haven't checked whether this situation can be hit in the gmodules case, but my money is on "yes". Differential Revision: https://reviews.llvm.org/D86216

This reverts commit d58fd4e. This broke compiler-rt compilation on macOS: codesign --sign - /Users/buildslave/jenkins/workspace/lldb-cmake/lldb-build/lib/clang/12.0.99/lib/darwin/libclang_rt.tsan_ios_dynamic.dylib ld: warning: ignoring file projects/compiler-rt/lib/tsan/CMakeFiles/clang_rt.tsan_ios_dynamic.dir/rtl/tsan_rtl_amd64.S.o, building for iOS-arm64 but attempting to link with file built for iOS Simulator-x86_64 ld: warning: ignoring file projects/compiler-rt/lib/tsan/CMakeFiles/clang_rt.tsan_ios_dynamic.dir/rtl/tsan_rtl_aarch64.S.o, building for iOS-arm64 but attempting to link with file built for iOS Simulator-x86_64 Undefined symbols for architecture arm64: "_wrap__setjmp", referenced from: substitution__setjmp in tsan_interceptors_posix.cpp.o "_wrap_setjmp", referenced from: substitution_setjmp in tsan_interceptors_posix.cpp.o "_wrap_sigsetjmp", referenced from: substitution_sigsetjmp in tsan_interceptors_posix.cpp.o ld: symbol(s) not found for architecture arm64

The normal scheme for tail folding reductions is to use: loop: p = phi(0, a) mask = ... x = masked_load(..., mask) a = add(x, p) s = select(mask, a, p) This means we need to keep the register p and a alive out of the loop, plus the mask. On a target with predicated operations we can instead generate the phi as p = phi(0, s). This ensures the select in the loop and we can fold select(m, add(a, b), c) to something like a vaddt c, a, b using the m predicate. This in turn allows us to tail predicate the entire loop. Differential Revision: https://reviews.llvm.org/D84741

This caused failures on clang-x390x-linux.

The dependencies in clang/lib/IndexSerialization/CMakeLists.txt were incomplete, leading to link errors for a -DBUILD_SHARED_LIBS=True build.

Similarly to D85836, collapse all Scalar float types to a single enum value, and use APFloat semantics to differentiate between. This simplifies the code, and opens to door to supporting other floating point semantics (which would be needed for fully supporting architectures with more interesting float types such as PPC). Differential Revision: https://reviews.llvm.org/D86220

Otherwise the docs-lld-html target fails to build using recent Sphinx with the following not very helpful error message: An error happened in rendering the page index. Reason: TemplateNotFound() It turns out the values in the html_sidebars dictionary always need to be lists now. See sphinx-doc/sphinx#6186

Differential Revision: https://reviews.llvm.org/D86227

Differential Revision: https://reviews.llvm.org/D86139

Reviewed By: lntue Differential Revision: https://reviews.llvm.org/D86267

At this point we have already ruled out all def operands, so we can't possibly see a dead implicit def operand.

…ats. This class helps in dealing with normal and subnormal numbers uniformly. Moreover, since this class has been designed to handle all floating formats across platforms, it helps implement floating point functions in a uniform manner. The implementations of frexp and logb have been switched to use this new class as it allows us to use just one implementation across all different floating point formats. Reviewed By: lntue Differential Revision: https://reviews.llvm.org/D86241

`lldb_private::ScriptInterpreterPython::CommandDataPython` inherits from `lldb_private::BreakpointOptions::CommandData`, but the latter does not have a virtual destructor. This leads to a new-delete-type-mismatch error when running certain tests (such as `functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py`) under asan.

This exposes the module optimization pipeline as a pass that can be applied stand-alone when using 'opt'. This helps ml inliner training scenarios, where we start with IR captured right before inlining, perform the inlining (-scc-oz-module-inliner) and then want to continue and observe the final IR (where this patch comes into play). We can then apply llc on the resulting IR to continue compilation down to native. Differential Revision: https://reviews.llvm.org/D86224

... in favour of the isPhysical/isVirtual methods.

Currently we don't do anything about these, neither in InstCombine, nor in SimplifyCFG's sinking. These happen exceedingly rarely, but i've seen them in the cases where PHI-aware aggregate reconstruction would have fired if not for them.

This ensures that we never encode an instruction which is unavailable, such as if we explicitly insert a forbidden instruction when lowering. This is particularly important on RISC-V given its high degree of modularity, and will become increasingly important as new standard extensions appear. Reviewed By: asb, lenary Differential Revision: https://reviews.llvm.org/D85015

There are no nxv16i8/nxv8i16 SDIV instructions, so these fixed width operations must be promoted to nxv4i32. Differential Revision: https://reviews.llvm.org/D86114

1. created a common completion for breakpoint names; 2. bound the breakpoint name common completion with eArgTypeBreakpointName; 3. implemented the dedicated completion for breakpoint read -N. Reviewed By: JDevlieghere Differential Revision: https://reviews.llvm.org/D80693

Then it is trivial to make the output indented (the second parameter of json::OStream::OStream specifies the indentation). Reviewed By: jhenderson, echristo Differential Revision: https://reviews.llvm.org/D86045

After removing the unnecessary `-mmacosx-version-min=10.12` compiler flag this test can run on all platforms. I confirmed that this test is green for iOS, iOS simulator, and watchOS simulator. Differential Revision: https://reviews.llvm.org/D85952

Move fixed length SDIV tests from sve-fixed-length-int-arith.ll to sve-fixed-length-int-div.ll. The former uses CHECK lines that verify legalization decisions. That's overkill for the i8/i16 SDIV tests, since they have a tricky legalization.

We don't test on very old versions of Apple platforms anymore. The following lit substitution concerning the minimum deployment target for ARC support can be removed. ``` %darwin_min_target_with_full_runtime_arc_support -> 10.11 ``` Differential Revision: https://reviews.llvm.org/D85803

This patch is the initial support for the General Dynamic Thread Local Local Storage model to produce code sequence and relocations correct to the ABI for the model when using PC relative memory operations. Patch by: NeHuang Reviewed By: stefanp Differential Revision: https://reviews.llvm.org/D82315

The SGPR spills happen in SILowerSGPRSpills() and allSGPRSpillsAreDead() make sure there are no SGPR spills pending during PEI. But the FP/BP spills happen during PEI and are exceptions. Use actual frame indices of FP/BP in allSGPRSpillsAreDead() to accommodate the exceptions. Differential Revision: https://reviews.llvm.org/D86291

Custom lower and widen odd sized loads up to the alignment. The default set of legalization actions doesn't have a way to represent this. This fixes naturally aligned <3 x s8> and <3 x s16> loads. This also starts moving towards eliminating the buggy and overcomplicated legalization rules for narrowing. All the memory size changes should be done in the lower or custom action, not NarrowScalar / FewerElements. These currently have redundant and ambiguous code with the lower action.

Assuming this is used to split a memory access into smaller pieces, the new access should still have the same aliasing properties as the original memory access. As far as I can tell, this wasn't intentionally dropped. It may be necessary to drop this if you are moving the operand outside of the bounds of the original object in such a way that it may alias another IR object, but I don't think any of the existing users are doing this. Some of the uses widen into unused alignment padding, which I think is OK.

This is a first step patch to enable constexpr support and testing to a large number of x86 intrinsics. All I've done here is provide a DEFAULT_FN_ATTRS_CONSTEXPR variant to our existing DEFAULT_FN_ATTRS tag approach that adds constexpr on c++ builds. The clang cuda headers do something similar. I've started with POPCNT mainly as its tiny and are wrappers to generic __builtin_* intrinsics which already act as constexpr. Differential Revision: https://reviews.llvm.org/D86229

Provider a wrapper around llvm::sys::path::home_directory in the FileSystem class. This will make it possible for the reproducers to intercept the call in a central place.

Removed the Standard to LLVM conversion patterns that were previously pulled in for testing purposes. This helps to separate the conversion to LLVM dialect of the MLIR module with both SPIR-V and Standard dialects in it (particularly helpful for SPIR-V cpu runner). Also, tests were changed accordingly. Reviewed By: mravishankar Differential Revision: https://reviews.llvm.org/D86285

…put redirection

The FileSystem initialization depends on the reproducer mode. It has been growing organically to the point where it deserves its own helper function. This also allows for early returns to simplify the code.

This method is used to get the DataExtractor when the expression is a location list. Reviewed By: labath Differential Revision: https://reviews.llvm.org/D86090

Add a folder to the affine.parallel op so that loop bounds expressions are canonicalized. Additionally, a new AffineParallelNormalizePass is added to adjust affine.parallel ops so that the lower bound is always 0 and the upper bound always represents a range with a step size of 1. Differential Revision: https://reviews.llvm.org/D84998

…ttern

PR46970: for `alias = aliasee`, the alias can be used in relocation processing and on ARM st_type does affect Thumb interworking. It is thus desirable for the alias to get the same st_type. Note that the st_size field should not be inherited because some tools use st_size=0 as a heuristic to detect aliases. Retaining st_size can thwart such heuristics and cause aliases to be preferred over the original symbols. Differential Revision: https://reviews.llvm.org/D86263

* Support macOS 11+ version scheme * Standardize substitution name `%min_deployment_target=x.y` * Remove unneeded error cases (the input version is hard-coded) * Specify version as tuple instead of string; no need to parse it These changes should also facilitate a future addition of a substitution that expands to "set deployment target to current target version" (https://reviews.llvm.org/D70151). Reviewed By: delcypher Differential Revision: https://reviews.llvm.org/D85925

Now that Clang is able to constant-evaluate void-typed expressions, disable showing hover-card values for them. It's not useful to say that an expression cast to void has value '<no value>', even if we can constant-evaluate it to that result!

We are now using a properly-substituted minimal deployment target compiler flag (`%min_macos_deployment_target=10.11`). Enable test on iOS and watchOS plus simulators. We are also not testing on very old platforms anymore, so we can remove some obsolete lit infrastructure.

No functionality change intended: there doesn't seem to be any way to cause Clang to print such a value, but they can show up when dumping APValues from a debugger.

Known bits for G_ANYEXT was incorrectly using KnownBits::zext, causing us to treat the high bits as zero even though they're (by definition) unknown. Differential Revision: https://reviews.llvm.org/D86323

After D85820 TERMINFO_LIB is undefined.

Broken after D86247

…modules enabled. HeaderSearch was marking requested HeaderFileInfo as Resolved only based on the presence of ExternalSource. As the result, using any module was enough to set ExternalSource and headers unknown to this module would have HeaderFileInfo with empty fields, including `isImport = 0`, `NumIncludes = 0`. Such HeaderFileInfo was preserved without changes regardless of how the header was used in other modules and caused incorrect result in `HeaderSearch::ShouldEnterIncludeFile`. Fix by marking HeaderFileInfo as Resolved only if ExternalSource knows about this header. rdar://problem/62126911 Reviewed By: bruno Differential Revision: https://reviews.llvm.org/D80263

D86247 fails on Windows. This reverts commit 428beba.

…er (NFC) Add an abstract base class that can be used to create other directory providers.

When replaying the reproducer, lldb should source the .lldbinit file that was captured by the reproducer and not the one in the current home directory. This requires that we store the home directory as part of the reproducer. By returning the virtual home directory during replay, we ensure the correct virtual path gets constructed which the VFS can then find and remap to the correct file in the reproducer root. This patch adds a new HomeDirectoryProvider, similar to the existing WorkingDirectoryProvider. As the home directory is not part of the VFS, it is stored in LLDB's FileSystem instance.

D77531 has a type for mfsprg, it should be mtsprg. This patch is to fix this typo.

explicit keyword is declared outside of class is invalid, invalid explicit declaration is handled inside DiagnoseFunctionSpecifiers() function. To avoid compiler crash in case of invalid explicit declaration, remove assertion. Reviewed By: rsmith Differential Revision: https://reviews.llvm.org/D83929

We have two ways of using the runtimes build setup to build the builtins. You can either have an empty LLVM_BUILTIN_TARGETS (or have it include the "default" target), in which case builtin_default_target is called to set up the default target, or you can have actual triples in LLVM_BUILTIN_TARGETS, in which case builtin_register_target is called for each triple. builtin_default_target lets you build the builtins for Darwin (assuming your default triple is Darwin); builtin_register_target does not. I don't understand the reason for this distinction. The Darwin builtins build is special in that a single CMake configure handles building the builtins for multiple platforms (e.g. macOS, iPhoneSimulator, and iOS) and architectures (e.g. arm64, armv7, and x86_64). Consequently, if you specify multiple Darwin triples in LLVM_BUILTIN_TARGETS, expecting each configure to only build for that particular triple, it won't work. However, if you specify a *single* x86_64-apple-darwin triple in LLVM_BUILTIN_TARGETS, that single configure will build the builtins for all Darwin targets, exactly the same way that the default target would. The only difference between the configuration for the default target and the x86_64-apple-darwin triple is that the latter runs the configuration with `-DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON`, but that makes no difference for Apple targets (none of the CMake codepaths which have different behavior based on that variable are run for Apple targets). I tested this by running two builtins builds on my Mac, one with the default target and one with the x86_64-apple-darwin19.5.0 target (which is the default target triple for my clang). The only relevant CMakeCache.txt difference was the following, and as discussed above, it has no effect on the actual build for Apple targets: ``` -//Default triple for which compiler-rt runtimes will be built. -COMPILER_RT_DEFAULT_TARGET_TRIPLE:STRING=x86_64-apple-darwin19.5.0 +//No help, variable specified on the command line. +COMPILER_RT_DEFAULT_TARGET_ONLY:UNINITIALIZED=ON ``` Furthermore, when I add the `-D` flag to compiler-rt's libtool invocations, the libraries produced by the two builds are *identical*. If anything, I would expect builtin_register_target to complain if you tried specifying a triple for a particular Apple platform triple (e.g. macosx), since that's the scenario in which it won't work as you want. The generic darwin triple should be fine though, as best as I can tell. I'm happy to add the error for specific Apple platform triples, either in this diff or in a follow-up. Reviewed By: phosek Differential Revision: https://reviews.llvm.org/D86313

Summary: - HIP uses an unsized extern array `extern __shared__ T s[]` to declare the dynamic shared memory, which size is not known at the compile time. Reviewers: arsenm, yaxunl, kpyzhov, b-sumner Subscribers: kzhuravl, jvesely, wdng, nhaehnle, dstuttard, tpr, t-tye, hiraditya, kerbowa, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D82496

This patch adds support for emitting multiple abbrev tables. Currently, compilation units will always reference the first abbrev table. Reviewed By: jhenderson, labath Differential Revision: https://reviews.llvm.org/D86194

ld.lld is an ELF linker. We can switch to the new LLD for Mach-O port when it's more complete, but for now, assume the user will have set CMAKE_LINKER correctly themselves when targeting Darwin.

This patch adds support for emitting multiple abbrev tables. Currently, compilation units will always reference the first abbrev table. Reviewed By: jhenderson, labath Differential Revision: https://reviews.llvm.org/D86194

This patch adds support for referencing different abbrev tables. We use 'ID' to distinguish abbrev tables and use 'AbbrevTableID' to explicitly assign an abbrev table to compilation units. The syntax is: ``` debug_abbrev: - ID: 0 Table: ... - ID: 1 Table: ... debug_info: - ... AbbrevTableID: 1 ## Reference the second abbrev table. - ... AbbrevTableID: 0 ## Reference the first abbrev table. ``` Reviewed By: jhenderson Differential Revision: https://reviews.llvm.org/D83116

If the type T is incomplete then sizeof(T) results in C++ compilation error at line: static constexpr bool value = sizeof(T) <= (2 * sizeof(void *)); This patch allows incomplete types in parameters of function. Example: using SomeFunc = void(SomeIncompleteType &); llvm::unique_function<SomeFuncType> SomeFunc; Reviewers: DaniilSuchkov, vvereschaka Differential Revision: https://reviews.llvm.org/D81554

…es." This reverts commit f7ff0ac. This change is causing build failure. http://lab.llvm.org:8011/builders/clang-cmake-armv7-global-isel/builds/10400

Refactor the way the reduction tree pass works in the MLIR Reduce tool by introducing a set of utilities that facilitate the implementation of new Reducer classes to be used in the passes. This will allow for the fast implementation of general transformations to operate on all mlir modules as well as custom transformations for different dialects. These utilities allow for the implementation of Reducer classes by simply defining a method that indexes the operations/blocks/regions to be transformed and a method to perform the deletion or transfomration based on the indexes. Create the transformSpace class member in the ReductionNode class to keep track of the indexes that have already been transformed or deleted at a current level. Delete the FunctionReducer class and replace it with the OpReducer class to reflect this new API while performing the same transformation and allowing the instantiation of a reduction pass for different types of operations at the module's highest hierarchichal level. Modify the SinglePath Traversal method to reflect the use of the new API. Reviewed: jpienaar Differential Revision: https://reviews.llvm.org/D85591

This fixes llvm.org/PR47104

Use the append_if CMake function from HandleLLVMOptions. Since we include this file in LLDBStandalone it should work in both for in-tree and out-of-tree builds.

We're not using any of the Backtrace_* CMake variables set by FindBacktrace in LLDB.

In e99dee8, the "out_of_memory_new_handler" was changed to be explicitly initialized instead of relying on a global static constructor. However before this change, install_out_of_memory_new_handler could be called multiple times while it asserts right now. We can be more tolerant to calling multiple time InitLLVM without reintroducing a global constructor for this handler. Differential Revision: https://reviews.llvm.org/D86330

…ProcessorTypeAndSubtype to do a proper bit test. Instead of ANDing with a one hot mask representing the bit to be tested, we were ANDing with just the bit number. This tests multiple bits none of them the correct one. This caused skylake-avx512, cascadelake and cooperlake to all be misdetected. Based on experiments with the Intel SDE, it seems that all of these CPUs are being detected as being cooperlake. This is bad since its the newest CPU of the 3.

Commit dbcfbff adds ppc.readflm and ppc.setflm intrinsics to read or write FPSCR register. This patch adds them to Clang. Reviewed By: steven.zhang Differential Revision: https://reviews.llvm.org/D85874

As part of D84741, this adds a target hook for the preferPredicatedReductionSelect option and makes use of it under MVE, allowing us to tail predicate most reduction loops. Differential Revision: https://reviews.llvm.org/D85980

Modify the ARM getCmpSelInstrCost implementation for the code size costs of selects. Now consider the legalization cost and increase the cost of i1 because those values wouldn't live in a general purpose register. We also make selects +1 more expensive to account for the IT instruction. Differential Revision: https://reviews.llvm.org/D82091

Differential Revision: https://reviews.llvm.org/D86298

When traversing memory uses to look for aliasing reads/writes, we only care about complete overwrites. This patch splits off the partial overwrite tracking from isOverwrite This avoids some unnecessary work when checking for read/write clobbers with MemorySSA-DSE. isOverwrite, which skips the partial overwrite tracking. This gives a relatively small improvement http://llvm-compile-time-tracker.com/compare.php?from=ef2a2f77f87553a0a4a39f518eb9ac86b756bda6&to=658f3905dd96d3415f3782adc712c79fa59a4665&stat=instructions This is part of the patches to bring down compile-time to the level referenced in http://lists.llvm.org/pipermail/llvm-dev/2020-August/144417.html Reviewed By: asbirlea Differential Revision: https://reviews.llvm.org/D86280

Currently we have `checkDRI` and two `createDRIFrom` methods which are used to create `DynRegionInfo` objects. And we have an issue: constructions like: `ObjF->getELFFile()->base() + P->p_offset` that are used in `createDRIFrom` functions might overflow. I had to revert `D85519` which triggered such UBSan failure. This NFC, simplifies and generalizes how we create `DynRegionInfo` objects. It will allow us to introduce more/better validation checks in a single place. It also will allow to change `createDRI` to return `Expected<>` so that we will be able to stop using the `reportError`, which is used inside currently, and have a warning instead. Differential revision: https://reviews.llvm.org/D86297

1. Complete `process load` with the common disk file completion, so there is not test provided for it; 2. Complete `process unload` with the tokens of valid loaded images. Thanks for Raphael's help on the test for `process unload`. Reviewed By: teemperor Differential Revision: https://reviews.llvm.org/D79887

Before we speculatively execute a basic block, query the cost of inserting the necessary select instructions against the phi folding threshold. For non-trivial insertions, a more accurate decision can probably be made during machine if-conversion. With minsize we query the CodeSize cost, otherwise we use SizeAndLatency. Differential Revision: https://reviews.llvm.org/D82438

Matches what we do in most other x86 headers

…Pass* callbacks Both AfterPass and AfterPassInvalidated pass instrumentation callbacks get additional parameter of type PreservedAnalyses. This patch was created by @fedor.sergeev. I have just slightly changed it. Reviewers: fedor.sergeev Differential Revision: https://reviews.llvm.org/D81555

Followup to D86229, this enables constexpr on the alternative (which fallback to generic code) POPCNT intrinsics defined in ia32intrin.h

In SelectionDAGBuilder always translate the fshl and fshr intrinsics to FSHL and FSHR (or ROTL and ROTR) instead of lowering them to shifts and ORs. Improve the legalization of FSHL and FSHR to avoid code quality regressions. Differential Revision: https://reviews.llvm.org/D77152

This adds conservative handling of AtomicRMW/AtomicCmpXChg to isDSEBarrier, similar to atomic loads and stores.

This enables constexpr BSWAP intrinsics defined in ia32intrin.h

Its a follow-up for D85830, it stops ignoring 'PT_OPENBSD_*' segment types. Now them are recognized properly. Note: GNU readelf does not recognize them, though perhaps it shouldn't. Anyways, it was reported to binutils: https://sourceware.org/bugzilla/show_bug.cgi?id=26405#c0 Differential revision: https://reviews.llvm.org/D86208

…and stores Adjust alignment requirements for ds_read/write_b96/b128. GFX9 and onwards allow misaligned access for reads and writes but only if SH_MEM_CONFIG.alignment_mode allows it. UnalignedDSAccess is set on GCN subtargets from GFX9 onward to let us know if we can relax alignment requirements. UnalignedAccessMode acts similary to UnalignedBufferAccess for DS instructions but only from GFX9 onward and is supposed to match alignment_mode. By default alignment of 4 is required. Differential Revision: https://reviews.llvm.org/D82788

Features UnalignedBufferAccess and UnalignedDSAccess are now used to determine whether hardware supports such access. UnalignedAccessMode should be used to enable them. hasUnalignedBufferAccessEnabled() and hasUnalignedDSAccessEnabled() can be now used to quickly check both. Differential Revision: https://reviews.llvm.org/D84522

Fix local ds_read/write_b96/b128 so they can be selected if the alignment allows. Otherwise, either pick appropriate ds_read2/write2 instructions or break them down. Differential Revision: https://reviews.llvm.org/D81638

Do not break down local loads and stores so ds_read/write_b96/b128 in ISelLowering can be selected on subtargets that support them and if align requirements allow them. Differential Revision: https://reviews.llvm.org/D84403

PseudoBRIND had seemingly inherited incorrect annotations denoting it as a call instruction and that it defines X1/ra. This caused excess save/restore code to be emitted for ra. Differential Revision: https://reviews.llvm.org/D86286

This enables constexpr BSF/BSR intrinsics defined in ia32intrin.h

Add some phi elimination threshold testing.

…bles. The original commit (7ff0ace96db9164dcde232c36cab6519ea4fce8) was causing build failure and was reverted in 6d242a7 ==================== Original Commit Message ==================== This patch adds support for referencing different abbrev tables. We use 'ID' to distinguish abbrev tables and use 'AbbrevTableID' to explicitly assign an abbrev table to compilation units. The syntax is: ``` debug_abbrev: - ID: 0 Table: ... - ID: 1 Table: ... debug_info: - ... AbbrevTableID: 1 ## Reference the second abbrev table. - ... AbbrevTableID: 0 ## Reference the first abbrev table. ``` Reviewed By: jhenderson Differential Revision: https://reviews.llvm.org/D83116

This can happen when building implicit modules, as demonstrated in test. The CompilerInstance uses the same StoredDiags, but different SourceManager. This used to crash clangd when it tried to relocate the diagnostic to the main file, which, according to SourceManager from the diagnostic, is a fake <module-includes> file. Differential Revision: https://reviews.llvm.org/D85753

Summary of changes: - added description of MTBUF instructions and format modifier; - described limitations of f16 inline constants when used with integer operands; - updated description of gfx9+ flat global addressing modes; - v_accvgpr_write_b32 src0 corrections (gfx908); - minor bugfixing and improvements.

Our handling of PC-Relative addressing is currently broken with Fast ISel in 3 ways: - FISel emits calls without handling all the PC-Rel intricacies - FISel materializes FP constants through the TOC - FISel materializes GV's through the TOC As it would be unnecessarily tedious to implement all the handling for PC-Rel in Fast ISel, we will turn off FISel for anything that generates references to the TOC.

…agnostic. The code that reports "PT_DYNAMIC segment offset + size exceeds the size of the file" has an issue: it is possible to bypass the validation by overflowing the size + offset result. Differential revision: https://reviews.llvm.org/D85519

D80465 added an assembly implementation of muldi3 for RISC-V but it didn't add it to the cmake `*_SOURCES` list, so the C implementation was being used instead. This patch fixes that. Differential Revision: https://reviews.llvm.org/D86036

The testing in merged.test is not ideal. It uses the following set of flags: `-aeWhSrnudlVgIs` and the precompiled object `trivial.obj.elf-i386`. In fact, this object, for example, does not contain versioning stuff, so specifying `-V` does not make much sense for it, so it is not really tested. Also, we want to avoid using of precompiled objects, ideally we want to use a YAML that triggers an output for each of the short options in use: ``` -a: --all -e: --headers -W: --wide -h: --file-headers, --file-header -S: --section-headers, --sections -r: --relocations -n: --notes -u: --unwind -d: --dynamic-table -l: --program-headers -V: --version-info -g: --elf-section-groups -I: --elf-hash-histogram -s: --symbols ``` Note that, for example, we do not need to have groups to test `-g`, because for a object with no groups llvm-readelf still prints "There are no section groups in this file.", but that is not always the case. E.g. for `-d` we don't print anything when we have no dynamic table, so we have to describe it in a YAML to test `-d` properly. Also, we probably want to test cases with and without `-a`(-all) option separately to be sure that we handle all options and not only the first one in the sequence. Differential revision: https://reviews.llvm.org/D86283

D81347 changes the ASTFileSignature to be an array of 20 uint8_t instead of 5 uint32_t. However, it didn't update the code in ObjectFilePCHContainerOperations that creates the dwoID in the module from the ASTFileSignature (`Buffer->Signature` being the array subclass that is now `std::array<uint8_t, 20>` instead of `std::array<uint32_t, 5>`). ``` uint64_t Signature = [..] (uint64_t)Buffer->Signature[1] << 32 | Buffer->Signature[0] ``` This code works with the old ASTFileSignature (where two uint32_t are enough to fill the uint64_t), but after the patch this only took two bytes from the ASTFileSignature and only partly filled the Signature uint64_t. This caused that the dwoID in the module ref and the dwoID in the actual module no longer match (which in turns causes that LLDB keeps warning about the dwoID's not matching when debugging -gmodules-compiled binaries). This patch just unifies the logic for turning the ASTFileSignature into an uint64_t which makes the dwoID match again (and should prevent issues like that in the future). Reviewed By: aprantl, dang Differential Revision: https://reviews.llvm.org/D84013

…eserved. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D85716

Pretty much just a copy of the SDIV patches (D86114 and D85982) with string replacement. Differential Revision: https://reviews.llvm.org/D86316

… expanding." Recommit the patch after fixing an issue reported caused by the fact that re-used values are also added to InsertedValues. Additional tests have been added in 8881849 This reverts the revert commit 3888464.

…347)" This reverts commit a4c3ed4. The test is curiously failing with a plain exit code 1 on Fuchsia.

Differential Revision: https://reviews.llvm.org/D86345

SUMMARY: Reviewers: Jason liu Differential Revision: https://reviews.llvm.org/D84265

This patch is the initial support for the Intial Exec Thread Local Local Storage model to produce code sequence and relocations correct to the ABI for the model when using PC relative memory operations. Reviewed By: stefanp Differential Revision: https://reviews.llvm.org/D81947

Currently ConstantExpr::getWithOperands does not handle FNeg and subsequently treats FNeg as binary operator, leading to an assertion failure or segmentation fault if built without assertions. Originally I reproduced this with llvm-dis on a bitcode file, which I unfortunately cannot share and also cannot really reduce. But PR45426 describes the same issue and has a reproducer with Clang, so I'll go with that. Reviewed By: aprantl Differential Revision: https://reviews.llvm.org/D86274

This commit teaches ASTDeclReader::attachPreviousDecl to successfully merge two Decl's when one contains an inheritable attribute like the MSInheritanceAttr. Usually, attributes that are needed to be present along the redeclaration chain are attached during ASTReading from ASTDeclReader::attachPreviousDecl, but no such thing is done for inheritable attributes. Currently, only the logic for merging MSInheritanceAttr is provided.

This reverts commit 7a527f1. It caused some buildbot failures: http://lab.llvm.org:8011/builders/clang-ppc64le-linux-multistage/builds/13600 http://lab.llvm.org:8011/builders/clang-cmake-armv7-quick/builds/20294

The only def for gc.relocate is a gc.statepoint. But real dependency is not described by def-use chain. Instead this dependency is encoded by indecies of operands in gc-live bundle of statepoint as integer constants in gc.relocate. InstCombine operates by def-use chain. As a result when value in gc-live bundle is simplified the gc.statepoint itself is not simplified but it might simplify dependent gc.relocates. To trigger the optimization of gc.relocate we now unconditionally trigger check of all dependent gc.relocates by adding them to worklist. This CL handles of gc.relocates as process of gc.statepoint optimization considering gc.statepoint and related gc.relocate as whole entity. Reviewers: reames, dantrushin Reviewed By: reames Subscribers: llvm-commits Differential Revision: https://reviews.llvm.org/D85954

… CrossOver mutator." This reverts commit bb54bcf. It is causing the value-profile-load.test test to fail on macOS.

With the log file being a build artifact we don't need to clean it up. If this happens before the reproducer is captured, the file will be missing from the reproducer root but being part of the mapping.

Binding MemRefs of f16 needs special handling as the type is not supported on CPU. There was a bug in the type used. Differential Revision: https://reviews.llvm.org/D86328

…/TLSLD The function `__tls_get_addr` is used to get the address of an object that is Thread Local Storage. It needs to have two relocations on it. One relocation is for the function call itself and it is either R_PPC64_REL24 or R_PPC64_REL24_NOTOC. The other is R_PPC64_TLSGD or R_PPC64_TLSLD for the symbol that is having its address computed. In the early days of the transition from the ELFv1 ABI that is used for big endian PowerPC Linux distributions to the ELFv2 ABI that is used for little endian PowerPC Linux distributions, there was some ambiguity in the specification of the relocations for TLS. The GNU linker has implemented support for correct handling of calls to __tls_get_addr with a missing relocation. Unfortunately, we didn't notice that the IBM XL compiler did not handle TLS according to the updated ABI until we tried linking XL compiled libraries with LLD. As a result, there is a lot of code out there in various libraries compiled with XL that have this problem. This patch adds a new error check in LLD that makes sure calls to `__tls_get_addr` are not missing the TLSGD/TLSLD relocation. Reviewed By: MaskRay Differential Revision: https://reviews.llvm.org/D85994

Reviewed By: mehdi_amini Differential Revision: https://reviews.llvm.org/D86326

This patch adds support for constrained scalar int to fp operations on PowerPC. Besides, this also fixes the FP exception bit of FCFID* instructions. Reviewed By: steven.zhang, uweigand Differential Revision: https://reviews.llvm.org/D81669

Refuse to run the shell tests when %lldb cannot be substituted. This prevents the test from silently running again the `lldb` in your PATH. I noticed because when this happens, %lldb-init gets substituted with lldb-init, which does not exists.

See http://lists.llvm.org/pipermail/llvm-dev/2017-June/113975.html for a related previous discussion. Many tools install signal handlers to print stack traces and optionally symbolize the addresses with an external program 'llvm-symbolizer' (when searching for 'llvm-symbolizer', the directory containg the executable is preferred over PATH). 'llvm-symbolizer' can be slow if the executable is large and/or if llvm-symbolizer' itself is under-optimized. For example, my 'llvm-lto2' from a -DCMAKE_BUILD_TYPE=Debug build is 443MiB. The 'llvm-symbolizer' from the same build takes ~2s to symbolize it. (An optimized 'llvm-symbolizer' takes 0.34s). A crashed clang may take more than 5s to symbolize a stack trace. If a test file has several `not --crash` RUN lines. It can be very slow in a Debug build. This patch makes `not --crash` set an environment variable to suppress symbolization. This is similar to D33804 which uses a command line option. I pick 'symbolization' instead of 'symbolication' because the former is used much more commonly and its stem matches 'llvm-symbolizer'. Also set LLVM_DISABLE_CRASH_REPORT=1, which is currently only applicable on `__APPLE__`. Reviewed By: dblaikie, aganea Differential Revision: https://reviews.llvm.org/D86170

…ing. Reviewed By: andreadb, lebedev.ri Differential Revision: https://reviews.llvm.org/D86177

If some of gc live value are not used in gc.relocate we can remove them from gc-live bundle of statepoint instruction. Also the CL removes duplicated Values in gc-live bundle. Reviewers: reames, dantrushin Reviewed By: dantrushin Subscribers: llvm-commits Differential Revision: https://reviews.llvm.org/D85959

The original commit was reverted in 58c305f due to broken bots. This commit corrects the triple and command line paths.

This is the slowest operation in the already slow pass. Instead of sorting just put a stall list into an ordered map. Differential Revision: https://reviews.llvm.org/D86253

…p_struct so the see also link in 'vector operations' will go to the right place and have the right name.

When trying to enable -debug-info-kind=constructor there was an assert that occurs during debug info cloning ("mismatched subprogram between llvm.dbg.value variable and !dbg attachment"). It appears that during llvm::CloneFunctionInto, a DISubprogram could be duplicated when MapMetadata is called, and then added to the MD map again when DIFinder gets a list of subprograms. This results in two different versions of the DISubprogram. This patch switches the order so that the DIFinder subprograms are added before MapMetadata is called. Fixes https://bugs.llvm.org/show_bug.cgi?id=46784 Differential Revision: https://reviews.llvm.org/D86185

Currently, `AANoUndefImpl::initialize` mistakenly always indicates optimistic fixpoint for function returned position. This is because an associated value is `Function` in the case, and `isGuaranteedNotToBeUndefOrPoison` returns true for Function. Reviewed By: jdoerfert Differential Revision: https://reviews.llvm.org/D86361

Before e5d08fc the Makefile would always compute the min-version, even if it wasn't set in the triple. This nuance got lost when passing the ARCH_CFLAGS directly from TestSimulatorPlatform.

- Adds a command line option to seed only selected functions. - Makes seed allow listing exclusive to assertions enabled builds. Reviewed By: sstefan1 Differential Revision: https://reviews.llvm.org/D86129

The register class is required for inserting PHIs, but the "current virtual register" isn't actually used for anything, so let's remove it while we're at it. Differential Revision: https://reviews.llvm.org/D85602 Change-Id: I1e647f31570ef21a7ea8e20db3454178e98a6a8b

The legacy PM alias analysis pipeline by default includes basic-aa. When running `opt -foo-pass` under the NPM and -disable-basic-aa is not specified, use basic-aa. This decreases the number of check-llvm failures under NPM from 913 to 752. Reviewed By: ychen, asbirlea Differential Revision: https://reviews.llvm.org/D86167

This new TableGen Programmer's Reference document replaces the current Language Introduction and Language Reference documents. It brings all the TableGen reference information into one document. As an experiment, I numbered the sections in the document. See what you think about that. Reviewed By: lattner Differential Revision: https://reviews.llvm.org/D85838 (changes by Nicolai Hähnle <nicolai.haehnle@amd.com>: - fixed build error due to toctree in docs/LangRef/index.rst - fixed reference to ProgRef) Change-Id: Ifbdfa39768b8a460aae2873103d31c7b347aff00

TGParser::ParseValue contains two recursive calls, one to parse the RHS of a list paste operator and one to parse the RHS of a paste operator in a class/def name. Both of these calls neglect to check the return value to see if it is null (because of some error). This causes a crash in the next line of code, which uses the return value. The code now checks for null returns. Differential Revision: https://reviews.llvm.org/D85852

The logic behind --rerun-all-issues was removed when we switched to LIT as the test driver. This patch just removes the dotest option and corresponding entry in configuration.py.

test referenced a relative path to a file, but the path was not correct relative to the project the test is in Differential Revision: https://reviews.llvm.org/D86368

…mmon instruction hoisting by default, enable late in pipeline" As disscussed in post-commit review starting with https://reviews.llvm.org/D84108#2227365 while this appears to be mostly a win overall, especially code-size-wise, this appears to shake //certain// code pattens in a way that is extremely unfavorable for performance (+30% runtime regression) on certain CPU's (i personally can't reproduce). So until the behaviour is better understood, and a path forward is mapped, let's back this out for now. This reverts commit 1d51dc3.

The TableGen range piece punctuator is currently '-' (e.g., {0-9}), which interacts oddly with the fact that an integer literal's sign is part of the literal. This patch replaces the '-' with the new punctuator '...'. The '-' punctuator is deprecated. Differential Revision: https://reviews.llvm.org/D85585 Change-Id: I3d53d14e23f878b142d8f84590dd465a0fb6c09c

@JDevlieghere

LLVM install component targets needs to be in the form of: install-{target}[-stripped] I tested with: ``` cmake ... -DLLVM_ENABLE_PROJECTS="clang;lldb" -DLLVM_DISTRIBUTION_COMPONENTS="lldb;liblldb;lldb-python-scripts;" ... DESTDIR=... ninja install-distribution ``` @JDevlieghere `finish_swig_python_scripts` is a really weird name for a distribution component, any reason that it has to be this way? Differential Revision: https://reviews.llvm.org/D86235

Extend the `applyUpdates` in DominatorTree to allow a post CFG view, different from the current CFG. This patch implements the functionality of updating an already up to date DT, to the desired PostCFGView. Combining a set of updates towards an up to date DT and a PostCFGView is not yet supported. Differential Revision: https://reviews.llvm.org/D85472

D80298 made Timer::total atomic, but this requires linking libatomic on some targets. Reviewed By: aaronpuchert Differential Revision: https://reviews.llvm.org/D85691

Remove unnecessary dependency on libSystem.

The functionality has been removed for a while and now the dotest argument has been removed asll.

…th strings This patch adds support for representing Fortran `character(n)`. Primarily patch is based out of D54114 with appropriate modifications. Test case IR is generated using our downstream classic-flang. We're in process of upstreaming flang PR's but classic-flang has dependencies on llvm, so this has to get in first. Patch includes functional test case for both IR and corresponding dwarf, furthermore it has been manually tested as well using GDB. Source snippet: ``` program assumedLength call sub('Hello') call sub('Goodbye') contains subroutine sub(string) implicit none character(len=*), intent(in) :: string print *, string end subroutine sub end program assumedLength ``` GDB: ``` (gdb) ptype string type = character (5) (gdb) p string $1 = 'Hello' ``` Reviewed By: aprantl, schweitz Differential Revision: https://reviews.llvm.org/D86305

llc doesn't seem to automatically pick default `--triple`. using `%llc_dwarf` should fix this. Builder: http://lab.llvm.org:8011/builders/clang-cmake-armv7-quick/builds/20310 Error log: bin/llc: error: : error: unable to get target for 'x86_64-unknown-linux-gnu', see --version and --triple.

Update vim syntax file to include more std ops, and for int types. Differential Revision: https://reviews.llvm.org/D86370

… when X86 target is not built

This patch updates the SPIR-V to LLVM conversion manual. Particularly, the following sections are added: - `spv.EntryPoint`/`spv.ExecutionMode` handling - Mapping for `spv.AccessChain` - Change in allowed storage classes for `spv.globalVariable` - Change of the runner section name Reviewed By: mravishankar Differential Revision: https://reviews.llvm.org/D86288

We can use BatchAA to avoid some repeated AA queries. We only remove stores, so I think we will get away with using a single BatchAA instance for the complete run. The changes in AliasAnalysis.h mirror the changes in D85583. The change improves compile-time by roughly 1%. http://llvm-compile-time-tracker.com/compare.php?from=67ad786353dfcc7633c65de11601d7823746378e&to=10529e5b43809808e8c198f88fffd8f756554e45&stat=instructions This is part of the patches to bring down compile-time to the level referenced in http://lists.llvm.org/pipermail/llvm-dev/2020-August/144417.html Reviewed By: asbirlea Differential Revision: https://reviews.llvm.org/D86275

When `Target::GetEntryPointAddress()` calls `exe_module->GetObjectFile()->GetEntryPointAddress()`, and the returned `entry_addr` is valid, it can immediately be returned. However, just before that, an `llvm::Error` value has been setup, but in this case it is not consumed before returning, like is done further below in the function. In https://bugs.freebsd.org/248745 we got a bug report for this, where a very simple test case aborts and dumps core: ``` * thread #1, name = 'testcase', stop reason = breakpoint 1.1 frame #0: 0x00000000002018d4 testcase`main(argc=1, argv=0x00007fffffffea18) at testcase.c:3:5 1 int main(int argc, char *argv[]) 2 { -> 3 return 0; 4 } (lldb) p argc Program aborted due to an unhandled Error: Error value was Success. (Note: Success values must still be checked prior to being destroyed). Thread 1 received signal SIGABRT, Aborted. thr_kill () at thr_kill.S:3 3 thr_kill.S: No such file or directory. (gdb) bt #0 thr_kill () at thr_kill.S:3 #1 0x00000008049a0004 in __raise (s=6) at /usr/src/lib/libc/gen/raise.c:52 intel#2 0x0000000804916229 in abort () at /usr/src/lib/libc/stdlib/abort.c:67 intel#3 0x000000000451b5f5 in fatalUncheckedError () at /usr/src/contrib/llvm-project/llvm/lib/Support/Error.cpp:112 intel#4 0x00000000019cf008 in GetEntryPointAddress () at /usr/src/contrib/llvm-project/llvm/include/llvm/Support/Error.h:267 intel#5 0x0000000001bccbd8 in ConstructorSetup () at /usr/src/contrib/llvm-project/lldb/source/Target/ThreadPlanCallFunction.cpp:67 intel#6 0x0000000001bcd2c0 in ThreadPlanCallFunction () at /usr/src/contrib/llvm-project/lldb/source/Target/ThreadPlanCallFunction.cpp:114 intel#7 0x00000000020076d4 in InferiorCallMmap () at /usr/src/contrib/llvm-project/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp:97 intel#8 0x0000000001f4be33 in DoAllocateMemory () at /usr/src/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp:604 intel#9 0x0000000001fe51b9 in AllocatePage () at /usr/src/contrib/llvm-project/lldb/source/Target/Memory.cpp:347 intel#10 0x0000000001fe5385 in AllocateMemory () at /usr/src/contrib/llvm-project/lldb/source/Target/Memory.cpp:383 intel#11 0x0000000001974da2 in AllocateMemory () at /usr/src/contrib/llvm-project/lldb/source/Target/Process.cpp:2301 intel#12 CanJIT () at /usr/src/contrib/llvm-project/lldb/source/Target/Process.cpp:2331 intel#13 0x0000000001a1bf3d in Evaluate () at /usr/src/contrib/llvm-project/lldb/source/Expression/UserExpression.cpp:190 intel#14 0x00000000019ce7a2 in EvaluateExpression () at /usr/src/contrib/llvm-project/lldb/source/Target/Target.cpp:2372 intel#15 0x0000000001ad784c in EvaluateExpression () at /usr/src/contrib/llvm-project/lldb/source/Commands/CommandObjectExpression.cpp:414 intel#16 0x0000000001ad86ae in DoExecute () at /usr/src/contrib/llvm-project/lldb/source/Commands/CommandObjectExpression.cpp:646 intel#17 0x0000000001a5e3ed in Execute () at /usr/src/contrib/llvm-project/lldb/source/Interpreter/CommandObject.cpp:1003 intel#18 0x0000000001a6c4a3 in HandleCommand () at /usr/src/contrib/llvm-project/lldb/source/Interpreter/CommandInterpreter.cpp:1762 intel#19 0x0000000001a6f98c in IOHandlerInputComplete () at /usr/src/contrib/llvm-project/lldb/source/Interpreter/CommandInterpreter.cpp:2760 intel#20 0x0000000001a90b08 in Run () at /usr/src/contrib/llvm-project/lldb/source/Core/IOHandler.cpp:548 intel#21 0x00000000019a6c6a in ExecuteIOHandlers () at /usr/src/contrib/llvm-project/lldb/source/Core/Debugger.cpp:903 intel#22 0x0000000001a70337 in RunCommandInterpreter () at /usr/src/contrib/llvm-project/lldb/source/Interpreter/CommandInterpreter.cpp:2946 intel#23 0x0000000001d9d812 in RunCommandInterpreter () at /usr/src/contrib/llvm-project/lldb/source/API/SBDebugger.cpp:1169 intel#24 0x0000000001918be8 in MainLoop () at /usr/src/contrib/llvm-project/lldb/tools/driver/Driver.cpp:675 intel#25 0x000000000191a114 in main () at /usr/src/contrib/llvm-project/lldb/tools/driver/Driver.cpp:890``` Fix the incorrect error catch by only instantiating an `Error` object if it is necessary. Reviewed By: JDevlieghere Differential Revision: https://reviews.llvm.org/D86355

This is a pure file move of LiveDebugValues.cpp ahead of the pass being refactored, with an experimental new implementation to follow. The motivation for these changes can be found here: http://lists.llvm.org/pipermail/llvm-dev/2020-June/142368.html And the other related changes can be found in the phabricator stack for this revision: Differential Revision: https://reviews.llvm.org/D83304

Adds support for detecting cases like `if (!true) ...`. Addresses [[ https://bugs.llvm.org/show_bug.cgi?id=47166 | readability-simplify-boolean-expr not detected for negated boolean literals. ]] Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D86176

@rsmith

Based off comment from @rsmith on D86339

This code handles the special-case of i8 stores, but it could be generalized to deal with other types.

This reverses the existing transform that would uniformly canonicalize any 'xor' after any shift. In the case of logical shifts, that turns a 'not' into an arbitrary 'xor' with constant, and that's probably not as good for analysis, SCEV, or codegen. The SCEV motivating case is discussed in: http://bugs.llvm.org/PR47136 There's an analysis motivating case at: http://bugs.llvm.org/PR38781 I did draft a patch that would do the same for 'ashr' but that's questionable because it's just swapping the position of a 'not' and uncovers at least 2 missing folds that we would probably need to deal with as preliminary steps. Alive proofs: https://rise4fun.com/Alive/BBV Name: shift right of 'not' Pre: C2 == (-1 u>> C1) %a = lshr i8 %x, C1 %r = xor i8 %a, C2 => %n = xor i8 %x, -1 %r = lshr i8 %n, C1 Name: shift left of 'not' Pre: C2 == (-1 << C1) %a = shl i8 %x, C1 %r = xor i8 %a, C2 => %n = xor i8 %x, -1 %r = shl i8 %n, C1 Name: ashr of 'not' %a = ashr i8 %x, C1 %r = xor i8 %a, -1 => %n = xor i8 %x, -1 %r = ashr i8 %n, C1 Differential Revision: https://reviews.llvm.org/D86243

This enables us to use the __builtin_rotateleft / __builtin_rotateright 8/16/32/64 intrinsics inside constexpr code. Differential Revision: https://reviews.llvm.org/D86342

This enables us to use the __builtin_bitreverse 8/16/32/64 intrinsics inside constexpr code. Differential Revision: https://reviews.llvm.org/D86339

This patch renames the current LiveDebugValues class to "VarLocBasedLDV" and removes the pass-registration code from it. It creates a separate LiveDebugValues class that deals with pass registration and management, that calls through to VarLocBasedLDV::ExtendRanges when runOnMachineFunction is called. This is done through the "LDVImpl" abstract class, so that a future patch can install the new instruction-referencing LiveDebugValues implementation and have it picked at runtime. No functional change is intended, just shuffling responsibilities. Differential Revision: https://reviews.llvm.org/D83046

-Wsuggest-override indicates this VarLocBasedLDV method needs the override keyword.

…into define. NFCI.

This switches from using G_EXTRACT in odd cases to widen with undef and unmerge.

VirtualUse of type UseKind::Inter expects the definition of a llvm::Value to be represented in another statement. In the bug report that statement has been removed due to its domain being empty. Scop::InstStmtMap for the llvm::Value's defintion still pointed to the removed statement, which resulted in the use-after-free. The defintion statement was removed by Simplify because it was considered to not be reachable by other uses; trivially because it is never executed due to its empty domain. However, no such thing happend to the using statement using the value altough its domain is also empty. Fix by always removing statements with empty domains in Simplify since these are not properly analyzable. A UseKind::Inter should always have a statement with its defintion due to LLVM's SSA form. Scop::removeStmtNotInDomainMap() also removes statements with empty domains but does so without considering the context as used by Simplify's analyzes. In another angle, InstStmtMap pointing to removed statements should not happen either and ForwardOpTree would have bailed out if the llvm::Value definition was not represented by a statement. This will be corrected in a followup-commit. This fixes llvm.org/PR47098

InstStmtMap became inconsistent with ScopStmt::getInstructions() after the statement's instructions is modified, e.g. by being considered unused by the Simplify pass or being moved by ForwardOpTree. Change ScopStmt::setInstructions() to also update its parent's InstStmtMap. Also add assertions checking the consistency.

Extract all the provider related logic from Reproducer.h and move it into its own header ReproducerProvider.h. These classes are seeing most of the development these days and this reorganization reduces incremental compilation from ~520 to ~110 files when making changes to the new header.

When we report an error for a bad character kind, don't keep it in the `DeclTypeSpec`. Otherwise there could be further problems. In this case, `ComputeOffsets()` got an assertion error because we didn't recognize `CHARACTER(*,8)` as needing a descriptor because of the bad kind. Fixes https://bugs.llvm.org/show_bug.cgi?id=47173 Differential Revision: https://reviews.llvm.org/D86357

The identifier `Expr` within the scope of the Expr class (including its temple specializations) refers to the current template/instantiation (see https://en.cppreference.com/w/cpp/language/injected-class-name for details). The `MapTemplate` template expect a non-instantiated template as the first template argument, not the concrete instantiation of `Expr`. At least msvc interprets `Expr` as the injected class name, whereas gcc and clang use the global `flang::evaluate::Expr` template. Disambiguate by explicitly using the namespace. This patch is part of the series to [[ http://lists.llvm.org/pipermail/flang-dev/2020-July/000448.html | make flang compilable with MS Visual Studio ]]. Reviewed By: DavidTruby Differential Revision: https://reviews.llvm.org/D85646

… crashes This helps with both debugging llvm-reduce and sometimes getting usefull result even if llvm-reduce crashes Reviewed By: lebedev.ri Differential Revision: https://reviews.llvm.org/D85996

This patch imports the instruction-referencing implementation of LiveDebugValues proposed here: http://lists.llvm.org/pipermail/llvm-dev/2020-June/142368.html The new implementation is unreachable in this patch, it's the next patch that enables it behind a command line switch. Briefly, rather than tracking variable locations by just their location as the 'VarLoc' implementation does, this implementation does it by value: * Each value defined in a function is numbered, and propagated through dataflow, * Each DBG_VALUE reads a machine value number from a machine location, * Variable _values_ are propagated through dataflow, * Variable values are translated back into locations, DBG_VALUEs inserted to specify where those locations are. The ultimate aim of this is to enable referring to variable values throughout post-isel code, rather than locations. Those patches will build on top of this new LiveDebugValues implementation in later patches -- it can't be done with the VarLoc implementation as we don't have value information, only locations. Differential Revision: https://reviews.llvm.org/D83047

`struct Py_buffer_RAII` definition uses explicit deleted functions which are not supported by SWIG 2 (only 3). To get around this I moved this struct to an .h file that is included to avoid being parsed by swig. Reviewed By: lawrence_danna Differential Revision: https://reviews.llvm.org/D86381

It will suppress the implicitly-declared copy assignment operator in C++20.

One of the bots objects to brace-initializing a tuple: http://lab.llvm.org:8011/builders/clang-cmake-x86_64-sde-avx512-linux/builds/43595/steps/build%20stage%201/logs/stdio As the tuple constructor is apparently explicit. Fall back to the (not as pretty) explicit construction of a tuple. I'd thought this was permitted behaviour; will investigate why this fails later.

…nfigurations When built in SEH mode, UnwindCursor contains a CONTEXT struct, which is aligned to 16 bytes in most configurations, causing the whole UnwindCursor object to have 16 byte alignment. This fixes backtraces using _Unwind_Backtrace on x86_64 mingw, where an unw_cursor_t allocated on the stack was misaligned before. This is an ABI break for this struct for this configuration, but very few callers call libunwind directly (and even fewer directly allocate an unw_cursor_t anyway). Differential Revision: https://reviews.llvm.org/D86102

…on. NFC. Msvc has trouble defining a struct/class and defining a constexpr symbol in the same declarator. It reports the following error: ``` basic-parsers.h(809): error C2131: expression did not evaluate to a constant basic-parsers.h(809): note: failure was caused by call of undefined function or one not declared 'constexpr' basic-parsers.h(809): note: see usage of 'Fortran::parser::OkParser::OkParser' ``` Fix the msvc compilation by splitting the two definitions into two separate declarators. This patch is part of the series to [[ http://lists.llvm.org/pipermail/flang-dev/2020-July/000448.html | make flang compilable with MS Visual Studio ]]. Reviewed By: DavidTruby, klausler Differential Revision: https://reviews.llvm.org/D85937

The global variable outputSections in the COFF writer was not cleared between runs which caused successive calls to lld::coff::link to generate invalid binaries. These binaries when loaded would result in "invalid win32 applications" and/or "bad image" errors. Differential Revision: https://reviews.llvm.org/D86401

This reverts commit 8e06bf6. It broke the polly-x86_64-linux-test-suite and aosp-O3-polly-before-vectorizer-unprofitable buildbots.

This should be NFC in terms of output because the endian check further down would bail out too, but we are wasting time by waiting to that point to give up. If we generalize that function to deal with more than i8 types, we should not have to deal with the degenerate case.

so that the user does not have to pipe the output to `jq` or `python -m json.tool`. This change makes testing more convenient because `-NEXT` patterns can be used. The "prettify by default" is a good tradeoff to make. The output size increases a bit. Differential Revision: https://reviews.llvm.org/D86318

…fdump --statistics change

gcc errors on this, but I'm nervous that since -mtune has been ignored by clang for so long that there may be code bases out there that pass 32-bit cpus to clang.

Currently, this function is present in the dynsym table of libunwind.so (on ELF targets). Make the function static instead. In the previous release (LLVM 10.x), this function was instead a lambda function inside LocalAddressSpace::findUnwindSections, and because LocalAddressSpace was marked with _LIBUNWIND_HIDDEN, the lambda function was also a hidden symbol. Differential Revision: https://reviews.llvm.org/D86372

This is aligning it with the other "translation" which operates on a MLIR input.

…n the model of `MlirOptMain()` (NFC) Differential Revision: https://reviews.llvm.org/D86408

…ith mlir-translate This will allow out-of-tree translation to register the dialects they expect to see in their input, on the model of getDependentDialects() for passes. Differential Revision: https://reviews.llvm.org/D86409

This addresses the issue raised here https://reviews.llvm.org/rG02bf5632a94da6c3570df002804f8d3f79c11bfc The `finish_swig_python` function might be called more than once so we need to create the distribution component target based on the swig target. Differential Revision: https://reviews.llvm.org/D86402

Address post-commit review in https://reviews.llvm.org/D86408

@rsmith

As suggested by @rsmith on PR47267, by replacing the builtin_memcpy bitcast pattern with builtin_bit_cast we can use _castf32_u32, _castu32_f32, _castf64_u64 and _castu64_f64 inside constant expresssions (constexpr). Although __builtin_bit_cast was added for c++20 it works on all clang c/c++ modes. Differential Revision: https://reviews.llvm.org/D86398

@rsmith

… used in constant expressions As suggested by @rsmith on D86398 - we should try to document the intrinsics that can be used in constexpr

The example demonstrates how to use a module summary index file produced for ThinLTO to: * find the module that defines the main entry point * find all extra modules that are required for the build A LIT test runs the example as part of the LLVM test suite [1] and shows how to create a module summary index file. The code also provides two Error types that can be useful when working with ThinLTO summaries. [1] if LLVM_BUILD_EXAMPLES=ON and platform is not Windows Differential Revision: https://reviews.llvm.org/D85974

Summary: Implemented modeling for get() method in SmartPtrModeling Reviewers: NoQ, Szelethus, vsavchenko, xazax.hun Reviewed By: NoQ, xazax.hun Subscribers: martong, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D86029

The pattern matching does not account for truncating stores, so it is unlikely to work at later stages. So we are likely wasting compile-time with no hope of improvement by running this later.

Small cleanup, also removes one instance of getting DataLayout without using it later.

This enables constexpr rotate intrinsics defined in ia32intrin.h, including the MS specific builtins.

…rge code model & PIC The following program miscompiles because rL216012 added static relocation model support but not for PIC. ``` // clang -fpic -mcmodel=large -O0 a.cc double foo() { return 42.0; } ``` This patch adds PIC support. Reviewed By: craig.topper Differential Revision: https://reviews.llvm.org/D86024

Removing terminators will result in invalid IR, making further reductions pointless. I do not think there is any valid use case where we actually want to create invalid IR as part of a reduction. Reviewed By: lebedev.ri Differential Revision: https://reviews.llvm.org/D86210

…negatible

…ry (NFC) MLIR is removing "soon" the global dialect registry, this patch is transitionning FIR to not rely on it anymore.

This patch fix the usage of the wait-argument in a clause and add several tests and fix the unparsing of the wait-argument. Reviewed By: sscalpone Differential Revision: https://reviews.llvm.org/D86325

…Support for the OpenBSD clang driver. If not overridden, AddClangSystemIncludeArgs's implementation is empty, so by default, no system include args are added to the Clang driver. This means that invoking Clang without the frontend must include a manual -I/usr/include flag, which is inconsistent behavior. Therefore, override and implement this method to match. Some boilerplate is also borrowed for handling of the other driver flags. While we are here, also override and enable HasNativeLLVMSupport. Patch by: 3405691582 (dana koch) Differential Revision: https://reviews.llvm.org/D86412

… the OpenBSD clang driver.

The issue mentioned has been fixed in D84996

This patch makes these operations legal, and add necessary codegen patterns. There's still some issue similar to D77033 for conversion from v1i128 type. But normal type tests synced in vector-constrained-fp-intrinsic are passed successfully. Reviewed By: uweigand Differential Revision: https://reviews.llvm.org/D83654

We hit the compiling time reported by https://bugs.llvm.org/show_bug.cgi?id=46877 and the reason is the same as D77319. So we need to remove the dead node we created to avoid increase the problem size of DAGCombiner. Reviewed By: Spatel Differential Revision: https://reviews.llvm.org/D86183

We may meet Invalid CTR loop crash when there's constrained ops inside. This patch adds constrained FP intrinsics to the list so that CTR loop verification doesn't complain about it. Reviewed By: steven.zhang Differential Revision: https://reviews.llvm.org/D81924

D70867 introduced support for expanding most ppc_fp128 operations. But sitofp/uitofp is missing. This patch adds that after D81669. Reviewed By: uweigand Differntial Revision: https://reviews.llvm.org/D81918

* Generic mlir.ir.Attribute class. * First standard attribute (mlir.ir.StringAttr), following the same pattern as generic vs standard types. * NamedAttribute class. Differential Revision: https://reviews.llvm.org/D86250

Add methods to access operands in a similar manner to NAryExpr. Differential Revision: https://reviews.llvm.org/D86083

… pass pipeline (NFC) Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D86327

@src

This is a fixup of commit 0819a64 (D77152) which could result in miscompiles. The miscompile could only happen for targets where isOperationLegalOrCustom could return different values for FSHL and FSHR. The commit mentioned above added logic in expandFunnelShift to convert between FSHL and FSHR by swapping direction of the funnel shift. However, that transform is only legal if we know that the shift count (modulo bitwidth) isn't zero. Basically, since fshr(-1,0,0)==0 and fshl(-1,0,0)==-1 then doing a rewrite such as fshr(X,Y,Z) => fshl(X,Y,0-Z) would be incorrect if Z modulo bitwidth, could be zero. ``` $ ./alive-tv /tmp/test.ll ---------------------------------------- define i32 @src(i32 %x, i32 %y, i32 %z) { %0: %t0 = fshl i32 %x, i32 %y, i32 %z ret i32 %t0 } => define i32 @tgt(i32 %x, i32 %y, i32 %z) { %0: %t0 = sub i32 32, %z %t1 = fshr i32 %x, i32 %y, i32 %t0 ret i32 %t1 } Transformation doesn't verify! ERROR: Value mismatch Example: i32 %x = #x00000000 (0) i32 %y = #x00000400 (1024) i32 %z = #x00000000 (0) Source: i32 %t0 = #x00000000 (0) Target: i32 %t0 = #x00000020 (32) i32 %t1 = #x00000400 (1024) Source value: #x00000000 (0) Target value: #x00000400 (1024) ``` It could be possible to add back the transform, given that logic is added to check that (Z % BW) can't be zero. Since there were no test cases proving that such a transform actually would be useful I decided to simply remove the faulty code in this patch. Reviewed By: foad, lebedev.ri Differential Revision: https://reviews.llvm.org/D86430

Combine the cost modelling and validity checks for the phi to select conversion in SpeculativelyExecuteBB, extracting the logic out into a function.

Reviewed By: dylanmckay Differential Revision: https://reviews.llvm.org/D85589 Patch by Julien Etienne

Now that the number of Scalar "types" has been reduced, these don't make sense anymore.

Avoids a -Wunused-variable with gcc.

Added SPIRVEntry::getDecoration(Decoration Kind) method returning vector of SPIRVDecorate* containing all decoration ptrs of matching Kind

Added new ctors for SPIRVDecorate and SPIRVDecoarteGeneric accepting two SPIRVWord for decorations with 2 literals

Added following decorations for function VCFloatControl attributes: DecorateFunctionRoundingModeINTEL DecorateFunctionDenormModeINTEL DecorateFunctionFloatingPointModeINTEL

The old version expected only extractelement instructions as users of load from built-in variable, whereas it is possible to get other kinds of instructions as users of this load. This patch replaces load from built-in global variable with a vector filled with ids.

This patch follows from 71039dd3c5dbfafab78f6b86a5bb06ba2af93c89 * Replaced the destination operand with the result of its intrinsic call for store inst. * Replaced the read-from operand with the result of its intrinsic call for load inst.

Propagate the change from LLVM commit 24c3dab ("DebugInfo: Emit class template parameters first, before members", 2020-08-17).

Update for LLVM commit a407ec9 ("Revert "Revert "[NFC][llvm] Make the contructors of `ElementCount` private.""", 2020-08-19).

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

LLVM and SPIRV-LLVM-Translator pulldown (WW35) #2362

LLVM and SPIRV-LLVM-Translator pulldown (WW35) #2362

Commits on Aug 20, 2020

Commits on Aug 21, 2020

Commits on Aug 22, 2020

Commits on Aug 23, 2020

Commits on Aug 24, 2020