WebAssembly: Update datalayout to match fp128 ABI change

[dschuff]

Summary

This fix goes along with d1a96e906cc03a95cfd41a1f22bdda92651250c7
and makes the fp128 alignment match clang's long double alignment.

[dschuff]

This fix should go in ASAP (or else we should revert d1a96e906cc03a95cfd41a1f22bdda92651250c7) to fix the mismatch between LLVM and clang.

[kripken]

clang/lib/Basic/Targets/WebAssembly.h

175

Should this not be

resetDataLayout("e-m:e-p:64:64-i64:64-f128:64-n32:64-S128-ni:1");

(that is, the first two numbers should be 64?)

[dschuff]

• fix wasm64 copypasta

clang/lib/Basic/Targets/WebAssembly.h

175

oops yes, that's a copypasta

[sunfish]

llvm/test/CodeGen/WebAssembly/varargs.ll

5

It appears this change means that we're no longer testing varargs on wasm32-unknown-unknown. Please update this test so that it tests both triples.

[dschuff]

llvm/test/CodeGen/WebAssembly/varargs.ll

5

Done in rGd4e2693a679927a62dd738dd3bba24863dcd290a

clang/lib/Basic/Targets/WebAssembly.h

 };
 
 class LLVM_LIBRARY_VISIBILITY WebAssembly32TargetInfo
     : public WebAssemblyTargetInfo {
 public:
   explicit WebAssembly32TargetInfo(const llvm::Triple &T,
                                    const TargetOptions &Opts)
       : WebAssemblyTargetInfo(T, Opts) {
+    if (T.isOSEmscripten())
+      resetDataLayout("e-m:e-p:32:32-i64:64-f128:64-n32:64-S128-ni:1");
+    else
       resetDataLayout("e-m:e-p:32:32-i64:64-n32:64-S128-ni:1");
   }
 
 protected:
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 };
 
 class LLVM_LIBRARY_VISIBILITY WebAssembly64TargetInfo
     : public WebAssemblyTargetInfo {
 public:
   explicit WebAssembly64TargetInfo(const llvm::Triple &T,
                                    const TargetOptions &Opts)
       : WebAssemblyTargetInfo(T, Opts) {
     LongAlign = LongWidth = 64;
     PointerAlign = PointerWidth = 64;
     SizeType = UnsignedLong;
     PtrDiffType = SignedLong;
     IntPtrType = SignedLong;
+    if (T.isOSEmscripten())
+      resetDataLayout("e-m:e-p:64:64-i64:64-f128:64-n32:64-S128-ni:1");
+    else
       resetDataLayout("e-m:e-p:64:64-i64:64-n32:64-S128-ni:1");
   }
 
 protected:
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 };
 } // namespace targets
 } // namespace clang
 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_WEBASSEMBLY_H

llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp

 }
 
 /// Create an WebAssembly architecture model.
 ///
 WebAssemblyTargetMachine::WebAssemblyTargetMachine(
     const Target &T, const Triple &TT, StringRef CPU, StringRef FS,
     const TargetOptions &Options, Optional<Reloc::Model> RM,
     Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT)
-    : LLVMTargetMachine(T,
-                        TT.isArch64Bit()
-                            ? "e-m:e-p:64:64-i64:64-n32:64-S128-ni:1"
-                            : "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1",
-                        TT, CPU, FS, Options, getEffectiveRelocModel(RM, TT),
-                        getEffectiveCodeModel(CM, CodeModel::Large), OL),
+    : LLVMTargetMachine(
+          T,
+              ? (TT.isOSEmscripten()
+                     ? "e-m:e-p:64:64-i64:64-f128:64-n32:64-S128-ni:1"
+                     : "e-m:e-p:64:64-i64:64-n32:64-S128-ni:1")
+              : (TT.isOSEmscripten()
+                     ? "e-m:e-p:32:32-i64:64-f128:64-n32:64-S128-ni:1"
+                     : "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1"),
       TLOF(new WebAssemblyTargetObjectFile()) {
   // WebAssembly type-checks instructions, but a noreturn function with a return
   // type that doesn't match the context will cause a check failure. So we lower
   // LLVM 'unreachable' to ISD::TRAP and then lower that to WebAssembly's
   // 'unreachable' instructions which is meant for that case.
   this->Options.TrapUnreachable = true;
 
   // WebAssembly treats each function as an independent unit. Force

llvm/test/CodeGen/WebAssembly/varargs.ll

 ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -verify-machineinstrs | FileCheck %s
 
 ; Test varargs constructs.
 
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
-target triple = "wasm32-unknown-unknown"
+target triple = "wasm32-unknown-emscripten"
 
 ; Test va_start.
 
 ; TODO: Test va_start.
 ; CHECK-LABEL: start:
 ; CHECK-NEXT: .functype start (i32, i32) -> ()
 ; CHECK-NOT: __stack_pointer
 define void @start(i8** %ap, ...) {

 define void @nonlegal_fixed(fp128 %x, ...) nounwind {
   ret void
 }
 
 ; Test that an fp128 argument is properly aligned and allocated
 ; within a vararg buffer.
 
 ; CHECK-LABEL: call_fp128_alignment:
-; CHECK:      global.get      $push7=, __stack_pointer
-; CHECK-NEXT: i32.const       $push8=, 32
-; CHECK-NEXT: i32.sub         $push12=, $pop7, $pop8
-; CHECK-NEXT: local.tee       $push11=, $1=, $pop12
-; CHECK-NEXT: global.set      __stack_pointer, $pop11
-; CHECK-NEXT: i32.const       $push0=, 24
+; CHECK:      global.get      $push5=, __stack_pointer
+; CHECK-NEXT: i32.const       $push6=, 32
+; CHECK-NEXT: i32.sub         $push10=, $pop5, $pop6
+; CHECK-NEXT: local.tee       $push9=, $1=, $pop10
+; CHECK-NEXT: global.set      __stack_pointer, $pop9
+; CHECK-NEXT: i32.const       $push0=, 16
 ; CHECK-NEXT: i32.add         $push1=, $1, $pop0
 ; CHECK-NEXT: i64.const       $push2=, -9223372036854775808
 ; CHECK-NEXT: i64.store       0($pop1), $pop2
-; CHECK-NEXT: i32.const       $push3=, 16
-; CHECK-NEXT: i32.add         $push4=, $1, $pop3
-; CHECK-NEXT: i64.const       $push5=, 1
-; CHECK-NEXT: i64.store       0($pop4), $pop5
-; CHECK-NEXT: i32.const       $push6=, 7
-; CHECK-NEXT: i32.store       0($1), $pop6
+; CHECK-NEXT: i64.const       $push3=, 1
+; CHECK-NEXT: i64.store       8($1), $pop3
+; CHECK-NEXT: i32.const       $push4=, 7
+; CHECK-NEXT: i32.store       0($1), $pop4
 ; CHECK-NEXT: call            callee, $1
 define void @call_fp128_alignment(i8* %p) {
 entry:
   call void (...) @callee(i8 7, fp128 0xL00000000000000018000000000000000)
   ret void
 }
 
 declare void @llvm.va_start(i8*)
 declare void @llvm.va_end(i8*)
 declare void @llvm.va_copy(i8*, i8*)