WebAssembly: generate global loads

[jfb]

Summary

I'll add global store as a follow-up.

Note that WebAssembly globals *must* be address not-taken, which allows for some magical optimizations by the in-browser JIT. The LLVM backend will need to linearize all address-taken globals into a heap, and GEP into that special global (and that'll need appending linkage when mashing object files together). This will be done later.

[jfb]

This patch is still incomplete, I just want to check the general direction makes sense with @sunfish. I'll move the definitions to the right place and handle all relevant types before committing (and test them).

I also realized that my previous patch should have handled i8 and i16 globals (since they're memory types), so I'll send a separate patch to do so, and then update this one with the appropriate types.

[• sunfishcode]

I would like to propose a different approach to global variables.

We should start by allocating all global variables inside the address space, using a plain old data section. This will be easy to do, it's what LLVM normally does, it'll support all global variables, and it's something we'll need to do anyway. And, it'll be easier to do if we don't have to contend with special-case tglobaladdr patterns up front.

Once that's done, we can talk about how best to optimize non-address-taken globals.

[jfb]

In D12393#234247, @sunfishcode wrote:

I would like to propose a different approach to global variables.

We should start by allocating all global variables inside the address space, using a plain old data section. This will be easy to do, it's what LLVM normally does, it'll support all global variables, and it's something we'll need to do anyway. And, it'll be easier to do if we don't have to contend with special-case tglobaladdr patterns up front.

Once that's done, we can talk about how best to optimize non-address-taken globals.

I'm not sure I understand what you propose: I want to map C++ non-address-taken variables to wasm globals, which aren't in linear memory and can't alias with linear memory. Trying to make sense of what you propose: we could move all address-not-taken variables to their own section, and then perform the lowering I propose?

We could also start by just ignoring wasm globals entirely (just have load/store and linear memory).

[jfb]

We discussed this offline, @sunfish was indeed suggesting that we handle globals later as an optimization, and only do linear memory for now. This sounds sensible, so I'll close the issue for now!

lib/Target/WebAssembly/WebAssemblyISD.def

 ///
 //===----------------------------------------------------------------------===//
 
 // NOTE: NO INCLUDE GUARD DESIRED!
 
 HANDLE_NODETYPE(CALL)
 HANDLE_NODETYPE(RETURN)
 HANDLE_NODETYPE(ARGUMENT)
+HANDLE_NODETYPE(LOADGLOBAL)
 HANDLE_NODETYPE(Wrapper)
 
 // add memory opcodes starting at ISD::FIRST_TARGET_MEMORY_OPCODE here...

lib/Target/WebAssembly/WebAssemblyInstrMemory.td

  * int64.store[int64]: (no conversion)
  * float32.store[float32]: (no conversion)
  * float64.store[float64]: (no conversion)
  * 
  * load_global: load the value of a given global variable
  * store_global: store a given value to a given global variable
  */
 
+def WebAssemblyLOADGLOBAL : SDNode<"WebAssemblyISD::LOADGLOBAL", SDTIntUnaryOp>;
+let mayLoad = 1 in
+def LOADGLOBAL : I<(outs Int32:$dst), (ins global:$addr),
+                   [(set Int32:$dst,
+                    (WebAssemblyLOADGLOBAL tglobaladdr:$addr))]>;
+def : Pat<(load (WebAssemblywrapper tglobaladdr:$addr)),
+          (LOADGLOBAL tglobaladdr:$addr)>;
+
 def page_size_I32 : I<(outs Int32:$dst), (ins),
                       [(set Int32:$dst, (int_wasm_page_size))]>,
                     Requires<[HasAddr32]>;
 def page_size_I64 : I<(outs Int64:$dst), (ins),
                       [(set Int64:$dst, (int_wasm_page_size))]>,
                     Requires<[HasAddr64]>;

test/CodeGen/WebAssembly/global-load.ll

+; RUN: llc < %s -asm-verbose=false | FileCheck %s
+
+; Test that global loads assemble as expected.
+
+target datalayout = "e-p:32:32-i64:64-v128:8:128-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+@life = private global i32 42;
+
+define i32 @answer() {
+; CHECK-LABEL: (func $answer
+; CHECK-NEXT: (result i32)
+; CHECK-NEXT: (setlocal @0 (loadglobal $life))
+; CHECK-NEXT: (return @0)
+  %universe = load i32, i32* @life
+  ret i32 %universe
+}
+
+; CHECK: (global $life i32 42)