llvm-project/llvm/lib/Target/WebAssembly
Hans Wennborg 13bdae8541 Revert r372285 "GlobalISel: Don't materialize immarg arguments to intrinsics"
This broke the Chromium build, causing it to fail with e.g.

  fatal error: error in backend: Cannot select: t362: v4i32 = X86ISD::VSHLI t392, Constant:i8<15>

See llvm-commits thread of r372285 for details.

This also reverts r372286, r372287, r372288, r372289, r372290, r372291,
r372292, r372293, r372296, and r372297, which seemed to depend on the
main commit.

> Encode them directly as an imm argument to G_INTRINSIC*.
>
> Since now intrinsics can now define what parameters are required to be
> immediates, avoid using registers for them. Intrinsics could
> potentially want a constant that isn't a legal register type. Also,
> since G_CONSTANT is subject to CSE and legalization, transforms could
> potentially obscure the value (and create extra work for the
> selector). The register bank of a G_CONSTANT is also meaningful, so
> this could throw off future folding and legalization logic for AMDGPU.
>
> This will be much more convenient to work with than needing to call
> getConstantVRegVal and checking if it may have failed for every
> constant intrinsic parameter. AMDGPU has quite a lot of intrinsics wth
> immarg operands, many of which need inspection during lowering. Having
> to find the value in a register is going to add a lot of boilerplate
> and waste compile time.
>
> SelectionDAG has always provided TargetConstant for constants which
> should not be legalized or materialized in a register. The distinction
> between Constant and TargetConstant was somewhat fuzzy, and there was
> no automatic way to force usage of TargetConstant for certain
> intrinsic parameters. They were both ultimately ConstantSDNode, and it
> was inconsistently used. It was quite easy to mis-select an
> instruction requiring an immediate. For SelectionDAG, start emitting
> TargetConstant for these arguments, and using timm to match them.
>
> Most of the work here is to cleanup target handling of constants. Some
> targets process intrinsics through intermediate custom nodes, which
> need to preserve TargetConstant usage to match the intrinsic
> expectation. Pattern inputs now need to distinguish whether a constant
> is merely compatible with an operand or whether it is mandatory.
>
> The GlobalISelEmitter needs to treat timm as a special case of a leaf
> node, simlar to MachineBasicBlock operands. This should also enable
> handling of patterns for some G_* instructions with immediates, like
> G_FENCE or G_EXTRACT.
>
> This does include a workaround for a crash in GlobalISelEmitter when
> ARM tries to uses "imm" in an output with a "timm" pattern source.

llvm-svn: 372314
2019-09-19 12:33:07 +00:00
..
AsmParser [WebAssembly][MC] Allow empty assembly functions 2019-08-19 19:04:54 +00:00
Disassembler Revert CMake: Make most target symbols hidden by default 2019-06-11 03:21:13 +00:00
MCTargetDesc [WebAssembly] Make __attribute__((used)) not imply export. 2019-08-29 22:40:00 +00:00
TargetInfo Revert CMake: Make most target symbols hidden by default 2019-06-11 03:21:13 +00:00
CMakeLists.txt [WebAssembly] Move InstPrinter files to MCTargetDesc. NFC 2019-05-13 03:32:41 +00:00
LLVMBuild.txt [WebAssembly] Move InstPrinter files to MCTargetDesc. NFC 2019-05-13 03:32:41 +00:00
README.txt [WebAssembly] Remove trailing whitespaces in tests (NFC) 2019-03-06 02:00:22 +00:00
WebAssembly.h [WebAssembly] Run ExplicitLocals pass after CFGStackify 2019-03-30 09:29:57 +00:00
WebAssembly.td [WebAssembly] Add multivalue and tail-call target features 2019-05-23 17:26:47 +00:00
WebAssemblyAddMissingPrototypes.cpp [WebAssembly] Make sret parameter work with AddMissingPrototypes 2019-07-09 02:10:33 +00:00
WebAssemblyArgumentMove.cpp [WebAssembly] refactored utilities to not depend on MachineInstr 2019-07-12 22:08:25 +00:00
WebAssemblyAsmPrinter.cpp [webassembly] Apply llvm-prefer-register-over-unsigned from clang-tidy to LLVM 2019-08-12 22:40:45 +00:00
WebAssemblyAsmPrinter.h [AsmPrinter] refactor to remove remove AsmVariant. NFC 2019-04-10 16:38:43 +00:00
WebAssemblyCFGSort.cpp [llvm] Migrate llvm::make_unique to std::make_unique 2019-08-15 15:54:37 +00:00
WebAssemblyCFGStackify.cpp [webassembly] Apply llvm-prefer-register-over-unsigned from clang-tidy to LLVM 2019-08-12 22:40:45 +00:00
WebAssemblyCallIndirectFixup.cpp [WebAssembly] Rename except_ref type to exnref 2019-07-15 22:49:25 +00:00
WebAssemblyDebugValueManager.cpp Update the file headers across all of the LLVM projects in the monorepo 2019-01-19 08:50:56 +00:00
WebAssemblyDebugValueManager.h Update the file headers across all of the LLVM projects in the monorepo 2019-01-19 08:50:56 +00:00
WebAssemblyExceptionInfo.cpp [WebAssembly] Exception handling: Switch to the new proposal 2019-01-30 03:21:57 +00:00
WebAssemblyExceptionInfo.h Update the file headers across all of the LLVM projects in the monorepo 2019-01-19 08:50:56 +00:00
WebAssemblyExplicitLocals.cpp [webassembly] Apply llvm-prefer-register-over-unsigned from clang-tidy to LLVM 2019-08-12 22:40:45 +00:00
WebAssemblyFastISel.cpp CodeGen: Migration to using Register 2019-08-06 03:59:31 +00:00
WebAssemblyFixFunctionBitcasts.cpp [WebAssembly] Handle aliases in WebAssemblyFixFunctionBitcasts 2019-08-21 19:52:33 +00:00
WebAssemblyFixIrreducibleControlFlow.cpp [webassembly] Apply llvm-prefer-register-over-unsigned from clang-tidy to LLVM 2019-08-12 22:40:45 +00:00
WebAssemblyFrameLowering.cpp [webassembly] Apply llvm-prefer-register-over-unsigned from clang-tidy to LLVM 2019-08-12 22:40:45 +00:00
WebAssemblyFrameLowering.h Update the file headers across all of the LLVM projects in the monorepo 2019-01-19 08:50:56 +00:00
WebAssemblyISD.def [WebAssembly] Implement tail calls and unify tablegen call classes 2019-06-26 16:17:15 +00:00
WebAssemblyISelDAGToDAG.cpp [WebAssembly] Add atomic.fence instruction 2019-08-28 23:13:43 +00:00
WebAssemblyISelLowering.cpp [WebAssembly] Restore defaults for stores per memop 2019-09-18 23:18:16 +00:00
WebAssemblyISelLowering.h [WebAssembly] Print error message for llvm.clear_cache intrinsic 2019-07-11 05:55:47 +00:00
WebAssemblyInstrAtomics.td [WebAssembly] Add atomic.fence instruction 2019-08-28 23:13:43 +00:00
WebAssemblyInstrBulkMemory.td Revert r372285 "GlobalISel: Don't materialize immarg arguments to intrinsics" 2019-09-19 12:33:07 +00:00
WebAssemblyInstrCall.td [WebAssembly] Rename except_ref type to exnref 2019-07-15 22:49:25 +00:00
WebAssemblyInstrControl.td [WebAssembly] Rename except_ref type to exnref 2019-07-15 22:49:25 +00:00
WebAssemblyInstrConv.td Update the file headers across all of the LLVM projects in the monorepo 2019-01-19 08:50:56 +00:00
WebAssemblyInstrFloat.td Update the file headers across all of the LLVM projects in the monorepo 2019-01-19 08:50:56 +00:00
WebAssemblyInstrFormats.td [WebAssembly] Make disassembler always emit most canonical name. 2019-02-05 01:19:45 +00:00
WebAssemblyInstrInfo.cpp Finish moving TargetRegisterInfo::isVirtualRegister() and friends to llvm::Register as started by r367614. NFC 2019-08-01 23:27:28 +00:00
WebAssemblyInstrInfo.h [WebAssembly] Use named operands to identify loads and stores 2019-03-09 04:31:37 +00:00
WebAssemblyInstrInfo.td [WebAssembly] Rename except_ref type to exnref 2019-07-15 22:49:25 +00:00
WebAssemblyInstrInteger.td [WebAssembly] Fix select of and (PR40805) 2019-02-23 18:59:01 +00:00
WebAssemblyInstrMemory.td [WebAssembly] Initial implementation of PIC code generation 2019-03-26 19:46:15 +00:00
WebAssemblyInstrRef.td [WebAssembly] Rename except_ref type to exnref 2019-07-15 22:49:25 +00:00
WebAssemblyInstrSIMD.td [WebAssembly] Narrowing and widening SIMD ops 2019-09-13 22:54:41 +00:00
WebAssemblyLateEHPrepare.cpp Use Register over unsigned in LateEHPrepare (NFC) 2019-08-13 17:35:44 +00:00
WebAssemblyLowerBrUnless.cpp [webassembly] Apply llvm-prefer-register-over-unsigned from clang-tidy to LLVM 2019-08-12 22:40:45 +00:00
WebAssemblyLowerEmscriptenEHSjLj.cpp [WebAssembly] Compare functions by names in Emscripten Sjlj 2019-09-03 22:26:49 +00:00
WebAssemblyLowerGlobalDtors.cpp IR. Change strip* family of functions to not look through aliases. 2019-08-22 19:56:14 +00:00
WebAssemblyMCInstLower.cpp [llvm] Migrate llvm::make_unique to std::make_unique 2019-08-15 15:54:37 +00:00
WebAssemblyMCInstLower.h [WebAssembly] Remove unneeded target operand flags 2019-04-03 00:17:29 +00:00
WebAssemblyMachineFunctionInfo.cpp [llvm] Migrate llvm::make_unique to std::make_unique 2019-08-15 15:54:37 +00:00
WebAssemblyMachineFunctionInfo.h Finish moving TargetRegisterInfo::isVirtualRegister() and friends to llvm::Register as started by r367614. NFC 2019-08-01 23:27:28 +00:00
WebAssemblyMemIntrinsicResults.cpp Change TargetLibraryInfo analysis passes to always require Function 2019-09-07 03:09:36 +00:00
WebAssemblyOptimizeLiveIntervals.cpp Finish moving TargetRegisterInfo::isVirtualRegister() and friends to llvm::Register as started by r367614. NFC 2019-08-01 23:27:28 +00:00
WebAssemblyOptimizeReturned.cpp [IR] Value: add replaceUsesWithIf() utility 2019-08-01 12:32:08 +00:00
WebAssemblyPeephole.cpp Change TargetLibraryInfo analysis passes to always require Function 2019-09-07 03:09:36 +00:00
WebAssemblyPrepareForLiveIntervals.cpp Finish moving TargetRegisterInfo::isVirtualRegister() and friends to llvm::Register as started by r367614. NFC 2019-08-01 23:27:28 +00:00
WebAssemblyRegColoring.cpp Finish moving TargetRegisterInfo::isVirtualRegister() and friends to llvm::Register as started by r367614. NFC 2019-08-01 23:27:28 +00:00
WebAssemblyRegNumbering.cpp Finish moving TargetRegisterInfo::isVirtualRegister() and friends to llvm::Register as started by r367614. NFC 2019-08-01 23:27:28 +00:00
WebAssemblyRegStackify.cpp [webassembly] Apply llvm-prefer-register-over-unsigned from clang-tidy to LLVM 2019-08-12 22:40:45 +00:00
WebAssemblyRegisterInfo.cpp [webassembly] Apply llvm-prefer-register-over-unsigned from clang-tidy to LLVM 2019-08-12 22:40:45 +00:00
WebAssemblyRegisterInfo.h CodeGen: Introduce a class for registers 2019-06-24 15:50:29 +00:00
WebAssemblyRegisterInfo.td [WebAssembly] Rename except_ref type to exnref 2019-07-15 22:49:25 +00:00
WebAssemblyReplacePhysRegs.cpp Update the file headers across all of the LLVM projects in the monorepo 2019-01-19 08:50:56 +00:00
WebAssemblyRuntimeLibcallSignatures.cpp [WebAssembly] Add signatures for RINT builtins 2019-05-29 01:06:00 +00:00
WebAssemblyRuntimeLibcallSignatures.h [WebAssembly] clang-tidy (NFC) 2019-02-04 19:13:39 +00:00
WebAssemblySelectionDAGInfo.cpp [WebAssembly] memory.fill 2019-02-13 22:25:18 +00:00
WebAssemblySelectionDAGInfo.h [WebAssembly] memory.fill 2019-02-13 22:25:18 +00:00
WebAssemblySetP2AlignOperands.cpp [WebAssembly] Use named operands to identify loads and stores 2019-03-09 04:31:37 +00:00
WebAssemblySubtarget.cpp [WebAssembly] Merge used feature sets, update atomics linkage policy 2019-03-29 00:14:01 +00:00
WebAssemblySubtarget.h [WebAssembly] Enable IndirectBrExpandPass 2019-07-03 23:54:06 +00:00
WebAssemblyTargetMachine.cpp [llvm] Migrate llvm::make_unique to std::make_unique 2019-08-15 15:54:37 +00:00
WebAssemblyTargetMachine.h [WebAssembly] Merge used feature sets, update atomics linkage policy 2019-03-29 00:14:01 +00:00
WebAssemblyTargetObjectFile.cpp Update the file headers across all of the LLVM projects in the monorepo 2019-01-19 08:50:56 +00:00
WebAssemblyTargetObjectFile.h Update the file headers across all of the LLVM projects in the monorepo 2019-01-19 08:50:56 +00:00
WebAssemblyTargetTransformInfo.cpp [WebAssembly] clang-tidy (NFC) 2019-02-04 19:13:39 +00:00
WebAssemblyTargetTransformInfo.h Update the file headers across all of the LLVM projects in the monorepo 2019-01-19 08:50:56 +00:00
WebAssemblyUtilities.cpp [webassembly] Apply llvm-prefer-register-over-unsigned from clang-tidy to LLVM 2019-08-12 22:40:45 +00:00
WebAssemblyUtilities.h [WebAssembly] refactored utilities to not depend on MachineInstr 2019-07-12 22:08:25 +00:00
known_gcc_test_failures.txt [WebAssembly] Update test failure explanations 2019-07-04 00:24:35 +00:00

README.txt

//===-- README.txt - Notes for WebAssembly code gen -----------------------===//

This WebAssembly backend is presently under development.

The most notable feature which is not yet stable is the ".o" file format.
".o" file support is needed for many common ways of using LLVM, such as
using it through "clang -c", so this backend is not yet considered widely
usable. However, this backend is usable within some language toolchain
packages:

Emscripten provides a C/C++ compilation environment that includes standard
libraries, tools, and packaging for producing WebAssembly applications that
can run in browsers and other environments. For more information, see the
Emscripten documentation in general, and this page in particular:

  * https://github.com/kripken/emscripten/wiki/New-WebAssembly-Backend

Rust provides WebAssembly support integrated into Cargo. There are two
main options:
 - wasm32-unknown-unknown, which provides a relatively minimal environment
   that has an emphasis on being "native"
 - wasm32-unknown-emscripten, which uses Emscripten internally and
   provides standard C/C++ libraries, filesystem emulation, GL and SDL
   bindings
For more information, see:
  * https://www.hellorust.com/


This backend does not yet support debug info. Full DWARF support needs a
design for how DWARF should be represented in WebAssembly. Sourcemap support
has an existing design and some corresponding browser implementations, so it
just needs implementing in LLVM.

Work-in-progress documentation for the ".o" file format is here:

  * https://github.com/WebAssembly/tool-conventions/blob/master/Linking.md

A corresponding linker implementation is also under development:

  * https://lld.llvm.org/WebAssembly.html

For more information on WebAssembly itself, see the home page:
  * https://webassembly.github.io/

The following documents contain some information on the semantics and binary
encoding of WebAssembly itself:
  * https://github.com/WebAssembly/design/blob/master/Semantics.md
  * https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md

The backend is built, tested and archived on the following waterfall:
  https://wasm-stat.us

The backend's bringup is done in part by using the GCC torture test suite, since
it doesn't require C library support. Current known failures are in
known_gcc_test_failures.txt, all other tests should pass. The waterfall will
turn red if not. Once most of these pass, further testing will use LLVM's own
test suite. The tests can be run locally using:
  https://github.com/WebAssembly/waterfall/blob/master/src/compile_torture_tests.py

Some notes on ways that the generated code could be improved follow:

//===---------------------------------------------------------------------===//

Br, br_if, and br_table instructions can support having a value on the value
stack across the jump (sometimes). We should (a) model this, and (b) extend
the stackifier to utilize it.

//===---------------------------------------------------------------------===//

The min/max instructions aren't exactly a<b?a:b because of NaN and negative zero
behavior. The ARM target has the same kind of min/max instructions and has
implemented optimizations for them; we should do similar optimizations for
WebAssembly.

//===---------------------------------------------------------------------===//

AArch64 runs SeparateConstOffsetFromGEPPass, followed by EarlyCSE and LICM.
Would these be useful to run for WebAssembly too? Also, it has an option to
run SimplifyCFG after running the AtomicExpand pass. Would this be useful for
us too?

//===---------------------------------------------------------------------===//

Register stackification uses the VALUE_STACK physical register to impose
ordering dependencies on instructions with stack operands. This is pessimistic;
we should consider alternate ways to model stack dependencies.

//===---------------------------------------------------------------------===//

Lots of things could be done in WebAssemblyTargetTransformInfo.cpp. Similarly,
there are numerous optimization-related hooks that can be overridden in
WebAssemblyTargetLowering.

//===---------------------------------------------------------------------===//

Instead of the OptimizeReturned pass, which should consider preserving the
"returned" attribute through to MachineInstrs and extending the
MemIntrinsicResults pass to do this optimization on calls too. That would also
let the WebAssemblyPeephole pass clean up dead defs for such calls, as it does
for stores.

//===---------------------------------------------------------------------===//

Consider implementing optimizeSelect, optimizeCompareInstr, optimizeCondBranch,
optimizeLoadInstr, and/or getMachineCombinerPatterns.

//===---------------------------------------------------------------------===//

Find a clean way to fix the problem which leads to the Shrink Wrapping pass
being run after the WebAssembly PEI pass.

//===---------------------------------------------------------------------===//

When setting multiple local variables to the same constant, we currently get
code like this:

    i32.const   $4=, 0
    i32.const   $3=, 0

It could be done with a smaller encoding like this:

    i32.const   $push5=, 0
    local.tee   $push6=, $4=, $pop5
    local.copy  $3=, $pop6

//===---------------------------------------------------------------------===//

WebAssembly registers are implicitly initialized to zero. Explicit zeroing is
therefore often redundant and could be optimized away.

//===---------------------------------------------------------------------===//

Small indices may use smaller encodings than large indices.
WebAssemblyRegColoring and/or WebAssemblyRegRenumbering should sort registers
according to their usage frequency to maximize the usage of smaller encodings.

//===---------------------------------------------------------------------===//

Many cases of irreducible control flow could be transformed more optimally
than via the transform in WebAssemblyFixIrreducibleControlFlow.cpp.

It may also be worthwhile to do transforms before register coloring,
particularly when duplicating code, to allow register coloring to be aware of
the duplication.

//===---------------------------------------------------------------------===//

WebAssemblyRegStackify could use AliasAnalysis to reorder loads and stores more
aggressively.

//===---------------------------------------------------------------------===//

WebAssemblyRegStackify is currently a greedy algorithm. This means that, for
example, a binary operator will stackify with its user before its operands.
However, if moving the binary operator to its user moves it to a place where
its operands can't be moved to, it would be better to leave it in place, or
perhaps move it up, so that it can stackify its operands. A binary operator
has two operands and one result, so in such cases there could be a net win by
preferring the operands.

//===---------------------------------------------------------------------===//

Instruction ordering has a significant influence on register stackification and
coloring. Consider experimenting with the MachineScheduler (enable via
enableMachineScheduler) and determine if it can be configured to schedule
instructions advantageously for this purpose.

//===---------------------------------------------------------------------===//

WebAssemblyRegStackify currently assumes that the stack must be empty after
an instruction with no return values, however wasm doesn't actually require
this. WebAssemblyRegStackify could be extended, or possibly rewritten, to take
full advantage of what WebAssembly permits.

//===---------------------------------------------------------------------===//

Add support for mergeable sections in the Wasm writer, such as for strings and
floating-point constants.

//===---------------------------------------------------------------------===//

The function @dynamic_alloca_redzone in test/CodeGen/WebAssembly/userstack.ll
ends up with a local.tee in its prolog which has an unused result, requiring
an extra drop:

    global.get  $push8=, 0
    local.tee   $push9=, 1, $pop8
    drop        $pop9
    [...]

The prologue code initially thinks it needs an FP register, but later it
turns out to be unneeded, so one could either approach this by being more
clever about not inserting code for an FP in the first place, or optimizing
away the copy later.

//===---------------------------------------------------------------------===//