[mlir][gpu] Add `uniform` flag to gpu reduction ops

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

Revert "[lld-macho][test][nfc] Update stabs.s to use touch -d instead of -t"

This reverts commit 3c9f479a5e47d5f3de07ccac365589dd928bfd20.
Breaks tests on macOS, see e.g. https://reviews.llvm.org/D139980#3993989

[WebAssembly][NFC] Add ComplexPattern for loads

This refactors out the offset and address operand pattern matching into
a ComplexPattern, so that one pattern fragment can match the dynamic and
static (offset) addresses in all possible positions.

Split out from D139530, which also contained an improvement to global
address folding.

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

[X86] Don't fold scalar_to_vector(i64 C) -> vzext_movl(scalar_to_vector(i32 C))

Fixes constant-folding infinite loop reported by @uabelho on rG5ca77541446d

[InstCombine] return the result of the GEP of PHI transformation early

Without this change this function could return nullptr if no further
transformation took place making InstCombine pass incorrectly report no
IR changes preventing analyses invalidation.

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

[Linker] Convert test to opaque pointers (NFC)

To preserve test intent, remove a pointer indirection and use
a GEP instead of bitcast, so the type is still mentioned.

[SCEV] Cache folded SExt SCEV expressions.

Use FoldID to cache SignExtendExprs that get folded to a different
SCEV.

Depends on D137505.

Reviewed By: mkazantsev

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

[Linker] Convert test to opaque pointers (NFC)

To preserve test intent, drop the pointer type.

re-land [RISC-V][HWASAN] Add support for HWASAN code instrumentation for RISC-V

now with the fixed warning and updated lit tests
---
[RISC-V][HWASAN] Add support for HWASAN code instrumentation for RISC-V

Reviewed By: vitalybuka

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

[Linker] Convert test to opaque pointers (NFC)

All the pointer-indirected cases are no longer relevant with
opaque pointers. To preserve at least some of the test intent,
switch to by value passing of the unnamed types. Otherwise we
wouldn't be testing anything at all.

[mlir][tensor][bufferize] Improve bufferization of DimOp/RankOp

The tensor operands do not bufferize to a memory read.

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

[mlir][memref] Fold no-op subview(subview(x)) ops

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

[LTO] Convert tests to opaque pointers (NFC)

[X86] lowerShuffleAsVTRUNC - bit shift the offset elements into place instead of shuffle

This helps avoid issues on non-BWI targets which can end up splitting the shuffles to 2 x 256-bit bitshifts of a smaller scalar width

[llvm-link] Convert test to opaque pointers (NFC)

To preserve test intent, remove the pointer types and replace by
value types, otherwise this wouldn't be testing anything at all.

mlir/ods-gen: use bash from env in shell script

On macOS, hardcoding the path of bash leads to a failure in executing
update_core_linalg_named_ops.sh, due to an old version of bash being
present in that location.

Signed-off-by: Ramkumar Ramachandra <r@artagnon.com>
Differential Revision: https://reviews.llvm.org/D139942

[mlir][NFC] Make test-lower-to-llvm a named pipeline

This patch changes the `test-lower-to-llvm` pass into a named pipeline.
The functionality is unchanged but thanks to this change, we don't have
to pull the dependencies of all the passes that this pass calls.
In other words, `TestLowerToLLVMPass::getDependDialects` was supposed to
transitively declare all the dialects that were used in the union of all
the invoked passes.

NFC

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

Revert "[InstCombine] Handle logical op in simplifyRangeCheck() (PR59484)"

This reverts commit 492c471839a66e354ebe696bd3e15f7477c63613.

As pointed out by nloped, the transform in f2 is not correct: If
%shr is poison, then freeze may result in a negative value. The
transform is correct in the case where the freeze is pushed through
the operation in a way that guarantees the result is non-negative,
which is the case I had tested.

[X86] lowerShuffleAsVTRUNC - improve detection of cheap/free vector concatenation

Handle the case where the lo/hi subvectors are a split load.

[AArch64][SVE][ISel] Combine dup of load to replicating load

(dup (load) z_or_x_passthrough) => (replicating load)

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

[bazel] add some more deps to libc BUILD files

[llvm-readobj] llvm::Optional => std::optional

Temporarily add expectedToStdOptional to llvm/Support/Error.h for migration.

[ExecutionEngine] llvm::Optional => std::optional

[bazel] Add __support_common dep

[FileCheck] llvm::Optional => std::optional

[include-cleaner] Print the line number of removal #includes.

I found that this information is helpful when using this tool.

Reviewed By: kadircet

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

[mlir][llvm] Add inbounds attriubte to the gep op.

The revision adds an inbounds attribute to the LLVM dialect
GEP operation. It extends the builders and the import and export
to support the optional inbounds attribute.

As all builders set inbounds to false by default, existing lowerings
from higher-level dialects to LLVM dialect are not affected by the
change. Canonicalization/folding remains untouched since it currently
does not implement any simplifications in case of undefined behavior
(the handling of undefined behavior is deferred to LLVM).

Reviewed By: ftynse

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

[clangd] Correct the local variable names to match the code style, NFC

[mlir][llvm] Fix bug in the LLVM IR constant import.

The recently introduced iterative constant import
(https://reviews.llvm.org/D137559) fails for programs that
subsequently import constant expressions with duplicate
subexpressions. The reason is a broken duplicate check
in getConstantsToConvert. The revision fixes the bug and
adds a test case that imports two constant expressions
with duplicates.

Reviewed By: ftynse

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

[AArch64][SVE] Add hadd and rhadd support

This adds basic HADD and RHADD support for SVE, by marking the AVGFLOOR
and AVGCEIL as custom and converting those to HADD_PRED/RHADD_PRED
AArch64 nodes. Both the existing intrinsics and the _PRED nodes are then
lowered to the _ZPmZ instructions.

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

Revert "Implement CWG2631"

This reverts commit f1f1b60c7ba607e9ffe3bc012161d43ef95ac773.

Temporary revert, possibly triggers a new assertion failure on
QualType::getCommonPtr.
We're working on a reproducer, to follow-up on
https://reviews.llvm.org/D136554.

[clang][analyzer] No new nodes when bug is detected in StdLibraryFunctionsChecker.

The checker applies constraints in a sequence and adds new nodes for these states.
If a constraint violation is found this sequence should be stopped with a sink
(error) node. Instead the `generateErrorNode` did add a new error node as a new
branch that is parallel to the other node sequence, the other branch was not
stopped and analysis was continuing on that invalid branch.
To add an error node after any previous node a new version of `generateErrorNode`
is needed, this function is added here and used by `StdLibraryFunctionsChecker`.
The added test executes a situation where the checker adds a number of
constraints before it finds a constraint violation.

Reviewed By: NoQ

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

[RISCV] Add Syntacore SCR1 CPU model

SCR1 is available at https://github.com/syntacore/scr1

'syntacore-scr1-base' corresponds to SCR1_CFG_RV32IC_BASE,
'syntacore-scr1-max' corresponds to SCR1_CFG_RV32IMC_MAX.

SCR1_CFG_RV32EC_MIN is RV32EC, which is currently unsupported.

Reviewed By: craig.topper

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

[Bitcode] Use std::nullopt_t instead of NoneType (NFC)

This is part of an effort to migrate from llvm::Optional to
std::optional:

https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716

[llvm-pdbutil] Update #includes (NFC)

The header file uses std::optional, but it's realying a transitive
inclusion of <optional>.  Meanwhile, it no longer uses llvm::Optional.

[libunwind] Use .irp directives. NFC

The repeated instructions make the file long and difficult to read.
Simplify them with .irp directives.

Skip PowerPC since AIX assembler doesn't support .irp

Reviewed By: #libunwind, compnerd

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

[tools] llvm::Optional => std::optional

[Analysis] llvm::Optional => std::optional

[Attributor][FIX] Avoid memory leakage through InstExclusionSet

[OpenMP][FIX] Restrict more unsound assmptions about threading

Even if all loads and stores are in `nosync` functions we cannot
guarantee there is no synchronization going on between them. As such, we
cannot use CFG reasoning. We could check the entire module, or, what
happens now to minimize test churn, is to check if all accesses are in
the same function that is `nosync`. A follow up will undo some of the
regressions where possible.

Similarly, reachability cannot be used to exclude an access if the
access is not known to be executed by the same thread as the given
instruction.

The OpenMP-opt test was added for the latter problem.

[gn] Port 5f68c4111ab9c79b902723df3986dd1033813c01

[clang] Remove uses of ::testing::Matcher<const Optional<T> &>

Change a few functions (getCheckTraversalKind, some clang/Tooling/ API, etc)
from llvm::Optional to std::optional.

[Testing/Support] llvm::Optional => std::optional

SupportHelpers.h supports both for now to ease migration.

[libc] Implement a high-precision floating point class.

Implement a high-precision floating point class using UInt<> as its
mantissa.  This will be used in accurate pass for double precision math
functions.

Reviewed By: sivachandra

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

[NFC] Cleanup: Replace BB->getInstList().erase() with I->eraseFromParent().

This is part of a series of patches that aim at making BasicBlock::getInstList() private.

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

[OpenMP][NFC] Remove more unused code, eliminate warning

[FuzzMutate] InstModStrategy: switch nsw/nuw/inbount instead of repeated setting it

Reviewed By: arsenm

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

[mlir][math] Added arith::FastMathAttr support for math::FPowI.

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

[Attributor] Introduce AA[Intra/Inter]Reachability

We had two AAs for reachability but it was very cumbersome to extend
them. We also had some fallback to use LLVM-core mechanisms and cache
the result. The new design shares the query code and interface nicely
between AAIntraFnReachability and AAInterFnReachability.

As part of the rewrite we also added the ExclusionSet to the queries.

[OpenMP][FIX] Remove accidental and somewhat random change

[NFC] [C++20] [Modules] Add more lambda tests

Add more lambda tests in modules. This is useful when we started to work
on https://github.com/llvm/llvm-project/issues/57222.

Warn about unsupported ibmlongdouble

When -mabi=ieeelongdouble is enabled by default, libc++ does not support
-mabi=ibmlongdouble.

Reviewed By: qiucf

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

[OpenMP][FIX] Remove unsound reasoning about written to values

Even if a value is for sure written we need to visit the call sites as
they might end up inside the function that reads and writes the value.
In a follow up we can introduce correct reasoning to avoid the backwards
traversal in this case and instead check if any call site between the
write and the read might reach a potential write we want to exclude.

[NFC] Rerun update test checks on Attributor and OpenMP-Opt tests

[OpenMP][NFCI] Remove effectively dead code in clang and the runtime

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

[mlir][Vector] Use llvm::zip to avoid assertion failed.

This patch fixes the issue https://github.com/llvm/llvm-project/issues/59455.
We could omit the un-changed dimensions in offsets and sizes, so llvm::zip_equal would fail in this case.

Reviewed By: Mogball

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

[mlir][Python] Add a simple PyOpOperand iterator for PyValue uses.

This adds a simple PyOpOperand based on MlirOpOperand, which can has
properties for the owner op and operation number.

This also adds a PyOpOperandIterator that defines methods for __iter__
and __next__ so PyOpOperands can be iterated over using the the
MlirOpOperand C API.

Finally, a uses psuedo-container is added to PyValue so the uses can
generically be iterated.

Depends on D139596

Reviewed By: stellaraccident, jdd

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

[OpenMP][Test] Make the output error message consistent with the comment

Modify the error message output of affinity/kmp-affinity.c and
affinity/omp-places.c.

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

[openmp][amdgpu] Let fine grain and kernarg pools differ

[VP][RISCV] Add vp.ctpop and RISC-V support.

The patch also adds expandVPCTPOP in TargetLowering to expand VP_CTPOP nodes.

Reviewed By: craig.topper

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

[mlir][tosa] Fix padding for tosa.conv2d and tosa.depthwise_conv2d decomposition

Decomposition did not take padding into account when decomposing into fully
connected operation.

Reviewed By: NatashaKnk

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

[flang] Fix a warning

This patch fixes:

  flang/lib/Lower/PFTBuilder.cpp:1042:6: error: function 'dumpScope'
  is not needed and will not be emitted
  [-Werror,-Wunneeded-internal-declaration]

[IPO] Fix a warning

This patch fixes:

  llvm/lib/Transforms/IPO/AttributorAttributes.cpp:1028:21: error:
  unused function 'operator<<' [-Werror,-Wunused-function]

[ubsan][test] Be more specific than "error:" with implicit-check-not

The string "error:" is too general and reports false positive from system
messages that can occur on stderr when using network devices for testing.
The string "runtime error:" is sufficiently unique for these connection
errors to pass through w/o a false positive.

rdar://100564373

Reviewed By: thetruestblue

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

[lld-macho][test][nfc] Update stabs.s to use touch -d instead of -t

The test currently uses `touch -t` (e.g., `env TZ=UTC touch -t
"197001010000.16"`) to set file timestamps. However, this does not seem to set
the time zone correctly in a singularity container. While this is probably a
bug/limitation of the singularity container, but we can instead use `touch
-d` (e.g., `touch -d "1970-01-01 00:00:16 UTC"`) to achieve the same result
without relying on a fix from singularity. Thoughts?

Reviewed By: int3, #lld-macho

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

[CMake] Setting the LLVM_TARGET_TRIPLE macro based on the LLVM_DEFAULT_TARGET_TRIPLE

After D137870, LLVM_TARGET_TRIPLE is no longer defined on the runtime
path into compiler-rt. This patch creates a common block of code to set
LLVM_TARGET_TRIPLE equal to the default for both the llvm- and runtime-
paths.

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

Revert "Reland "[compiler-rt][test] Heed COMPILER_RT_DEBUG when compiling unittests""

This reverts commit 255c3e3dcb06299aa2365f70817322a8a381c351, which
breaks Msan-x86_64-Test.

[NFC] [DirectX backend] copy dxil-dis as exe file on windows

Without .exe in the name on windows, the test not work.

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

[LSAN][NFC] Eliminated GetThreadRegistryLocked from the LSAN interface to avoid the need to implement it in HWASAN.

Reviewed By: vitalybuka

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

[mlir] Fix a warning

This patch fixes:

  mlir/lib/Dialect/Linalg/Transforms/DataLayoutPropagation.cpp:52:42:
  error: 'None' is deprecated: Use std::nullopt
  instead. [-Werror,-Wdeprecated-declarations]

[flang] Fix build failure

[X86] Don't zero out %eax if both %al and %ah are used

The iterator over super and sub registers doesn't include both 8-bit
registers in its list. So if both registers are used and only one of
them is live on return, then we need to make sure that the other 8-bit
register is also marked as live and not zeroed out.

Reviewed By: nickdesaulniers

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

[SPARC] Add GNU syntax extensions of WRPR instruction

Add two GNU extension forms of wrpr:

wrpr %reg, %rd -> wrpr %reg, %g0, %rd
wrpr  imm, %rd -> wrpr  %g0, imm, %rd

Note: since the semantics of wrpr %rs1, %rs2/imm, %rd is %rd <- (%rs1 xor %rs2/imm),
in case (1) it technically doesn't matter whether the %g0 is placed as the first or
second operand, however, I'm placing it as the second operand to match the encoding
of GNU as.

This fixes the wrpr instruction part of bug #40792

Reviewed By: arsenm

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

[llvm][Object] set SF_Hidden flag for MachO files

Reviewed By: pete, ributzka

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

Skip TestEarlyProcessLaunch.py w/ system debugserver

This test depends on having a new packet supported by debugserver;
skip it until we have a system debugserver installed on the CI bots
with this change.

[NFC][X86][Codegen] Fix test coverage for AVX512 i1 mask replication

At least some of the seemingly-bad codegen was because we really need to
consume the replicated i1 mask by the mask-consuming instruction
if we want faithful codegen for the replication shuffle.

But some of the odd codegen is still there.

Don't try to look up a name containing a dependent type.

Template instantiation can create names that are still dependent, such
as `operator T`. Don't assume that they can be looked up immediately,
and instead defer lookup for such names until we know what `T` is.

[NFC] Cleanup: Remove uses of BasicBlock::getInstList().

This is part of a series of patches that aim at making Function::getInstList() private.

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

[SPARC] Mark the %g0 register as constant & use it to materialize zeros

Materialize zeros by copying from %g0, which is now marked as constant.

This makes it possible for some common operations (like integer negation) to be
performed in fewer instructions.

This continues @arichardson's patch at D132561.

Reviewed By: arsenm

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

[mlir][tensor][linalg] Enhance pack op propagation across generic ops.

Considering the case that generic + pack (with outer_dim_perms), the
truth is that it is equipvelent to generic + pack + transpose. There are
two steps to bubble up the pack op accross the generic op.

Step 1. swap generic + pack -> pack + generic.

In this step, we can bind the packing information to dimensions of
iteration domain. With the information, we can pack the operands with
corresponding data tile sizes; the packed inner dimensions will be
appended to the indexing_maps. Note that the outer dimensions of
indexing maps are not changed at all.

Step 2. Fold the transpose into generic op.

The step two is just updating the indexing map, so we do not have to
handle outer_dim_perms anymore.

There could be step 3 to extract the transpose op out (i.e., generic ->
transpose + generic), then we can fold the transpose into the pack op.
This step is not done in the revision.

Co-authored-by: Lorenzo Chelini <l.chelini@icloud.com>
Reviewed By: chelini

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

[ValueTracking] peek through extends in haveNoCommonBitsSet (2nd try)

The 1st try was not clean because a portion of the code diff
made it into the pre-commit patch to add tests. This should
be the same end result without the muddied code diff.

Original commit message:

In cases with matching extends, this allows changing an 'add'
into an 'or' and narrowing the 'or' which then simplifies to
a constant.

In cases with opposite extends, we just convert to an 'or'
currently, but that could be reduced too.

https://alive2.llvm.org/ce/z/fTHzdb

[lld-macho][test] Add test case for section ordering

This covers the special section ordering handling. This chooses to fake the sections vs creating them organically which is probably a bit easier to maintain.

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

[llvm][tests] Don't run -O2 on instcombine test [NFC]

[HWASAN][NFC] Added implementation for the most of the allocator related functions from the LSAN interface.

Reviewed By: vitalybuka

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

[mlir][sparse] Make some integration tests run with vectorization.

Reviewed By: Peiming

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

[lld-macho] Fix __objc_stubs ordering

In the case of large binaries previously you could end up getting
relocation failures. This mirrors ld64's ordering of these sections. I'm
not sure this solves all cases but it should help in some.

Fixes https://github.com/llvm/llvm-project/issues/58298

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

[InstCombine] add tests for add-of-extends; NFC (2nd try)

The 1st attempt ( c8cba0bc4a8c9f ) accidentally picked up a code diff.

Revert "[InstCombine] add tests for add-of-extends; NFC"

This reverts commit c8cba0bc4a8c9f4f3f10e17f601ed924dfb82bef.
An unintended code change snuck into this (was supposed to just add tests).

Revert "[ValueTracking] peek through extends in haveNoCommonBitsSet"

This reverts commit 7520d187cf0dedcf5085f71bc1a5472c75cc8dbb.

The pre-commit patch that was supposed to NFC add tests for this
patch picked up some code that should not be here. I'll clean up
and re-commit.

[flang] Submodules

A submodule is a program unit that may contain the implementions of procedures
declared in an ancestor module or submodule.

Processing for the equivalence groups and variables declared in a submodule
scope is similar to existing processing for the equivalence groups and
variables in module and procedure scopes. However, module and procedure scopes
are tied directly to code in the Pre-FIR Tree (PFT), whereas processing for a
submodule must have access to an ancestor module scope that is guaranteed
to be present in a .mod file, but is not guaranteed to be in the PFT. This
difference is accommodated by tying processing directly to a front end scope.
Function scopes that can be processed on the fly are done that way; the
resulting variable information is never stored. Module and submodule scopes
whose symbol information may be needed during lowering of any number of module
procedures are instead cached on first use, and reused as needed.

These changes are a direct extension of current code. All module and submodule
variables in scope are processed, whether referenced or not. A possible
alternative would be to instead process symbols only when first used. While
this could ultimately be beneficial, such an approach must account for the
presence of equivalence groups. That information is not currently available
for on-the-fly variable processing.

Some additional changes are needed to include submodules in places where
modules must be considered, and to include separate module procedures in
places where other subprogram variants are considered. There is also a fix
for a bug involving the use of variables in an equivalence group in a
namelist group, which also involves scope processing code.

[ValueTracking] peek through extends in haveNoCommonBitsSet

In cases with matching extends, this allows changing an 'add'
into an 'or' and narrowing the 'or' which then simplifies to
a constant.

In cases with opposite extends, we just convert to an 'or'
currently, but that could be reduced too.

https://alive2.llvm.org/ce/z/fTHzdb

[InstCombine] add tests for add-of-extends; NFC

[libc] add scanf int conversions

This patch adds the integer conversions %d/i/u/o/x/X to scanf as well as
unit tests to check their correctness.

Reviewed By: sivachandra

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

[libc] fix scanf error handling

Scanf is supposed to return EOF when it fails to make any conversions
and there is an input failure. Previously it would return EOF on a
matching failure, which may be an input failure but can also be a
parsing error.

Reviewed By: sivachandra

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

[InstCombine] Fold logic-and/logic-or by distributive laws

X && Z || Y && Z --> (X || Y) && Z
https://alive2.llvm.org/ce/z/nM6kZb

(X || Z) && (Y || Z) --> (X && Y) || Z
https://alive2.llvm.org/ce/z/_EWLRR

Fix: https://github.com/llvm/llvm-project/issues/53861

Reviewed By: spatel

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

Use different export file when linking with dylib

This fixes compilation of clang with lld, as reported in
https://reviews.llvm.org/D135402.

Basically some symbols are not available when not linking statically.

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

[mlir][crunner] Add support for invoking std::sort.

Reviewed By: aartbik

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

[flang] emit warning when encountering a non-variable actual argument when its corresponding dummy argument expects a VOLATILE variable

This patch implements @klausler's suggestion in `llvm-project` [issue #58973](https://github.com/llvm/llvm-project/issues/58973); encountering the `VOLATILE` attribute should produce a __warning__, not a __fatal error__.

When tested on the following Fortran program `snem0601_012_.f90`:
```fortran
  module mod
    contains
    subroutine sub(m6,error)
    integer,intent(inout) :: error

    integer,volatile :: m6

    if (any ((/m6/).ne.(/6/))) &
   & then
       error = 1
    end if
    end subroutine
  end module

  program fe1nvol12

    use mod
    integer :: error = 0

    call sub(6,error)

    if (error .ne. 0) then
      print *,'NG: snem0601_012'
    end if

    print *,'pass: snem0601_012'

  end program fe1nvol12
```

the following output is produced:

```bash
$ flang-new -fc1 snem0601_012_.f90
/noback/93u/Sandbox/issue_58973_volatile_dummy_arg/snem0601_012_.f90:21:12: warning: actual argument associated with VOLATILE dummy argument 'm6=' is not a variable
    call sub(6,error)
             ^
```

Reviewed By: clementval, klausler

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

[bazel] Add __support_compiler_features dep in more places

[RISCV] Reuse VL (if non-zero) when building single element vector for start of reduction chain

This is an alternative patch on a path to D137530.

The basic problem being tackled here is that we need to place a scalar into lane 0 of a vector register before our reduction instructions. Since we only care about lane 0 of the vector, we can use any VL >= 1 provided that the total amount of work performed matches the work performed for a VL=1.

This change does not contain the logic from D137530 to perform the insert at the original VT, and then extract down to LMUL1. That turns out to be a good choice, as discussion in this review has indicated there are issues around LMUL2 and above with our representation of vmv.s.x. We'd also need to be careful with the splat logic for the same reasons.

The only potentially concerning codegen change I spot here is that we stop using a broadcast load (for VL=1) and instead do a scalar load and insert. I think this is probably reasonable; if reviewers disagree, I can investigate using a broadcast load which writes to the undef lanes. If we want to do that, we should do it for VECTOR_INSERT_ELT as well, so that'll end up as it's own patch series.

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