WebAssembly: Implement call

[jfb]

Summary

Support function calls.

[jfb]

This is still a work in progress, I need to figure out this void function problem, and add tests.

test/CodeGen/WebAssembly/call.ll

22 ↗

(On Diff #32762)

I'm a bit confused: functions without a return type don't work at the moment. They get eliminated by initial selection DAG:

=== call_void_nullary                                                    === call_i32_nullary                                                    
Initial selection DAG: BB#0 'call_void_nullary:'                         Initial selection DAG: BB#0 'call_i32_nullary:'                         
SelectionDAG has 7 nodes:                                                SelectionDAG has 7 nodes:                                               
  0x2e16db8: i32 = TargetConstant<0>                                       0x37d2ed8: i32 = TargetConstant<0>                                    
                                                                                                                                                 
    0x2de2880: ch = EntryToken                                                 0x379e9a0: ch = EntryToken                                        
                                                                                                                                                 
    0x2e16db8: <multiple use>                                                                                                                    
  0x2e16ee0: ch,glue = callseq_start 0x2de2880, 0x2e16db8 [ORD=2]                                                                                
                                                                                                                                                 
    0x2e16ee0: <multiple use>                                                                                                                    
    0x2e16c90: i32 = GlobalAddress<void ()* @void_nullary> 0 [ORD=2]                                                                             
                                                                                                                                                 
  0x2e17008: ch = WebAssemblyISD::CALL 0x2e16ee0, 0x2e16c90 [ORD=2]                                                                              
                                                                                                                                                 
      0x2e16ee0: <multiple use>                                                                                                                  
      0x2e16db8: <multiple use>                                                0x37d2ed8: <multiple use>                                         
                                                                             0x37d3000: ch,glue = callseq_start 0x379e9a0, 0x37d2ed8 [ORD=2]     
                                                                                                                                                 
                                                                             0x37d2db0: i32 = GlobalAddress<i32 ()* @i32_nullary> 0 [ORD=2]      
                                                                                                                                                 
                                                                           0x37d3128: i32,ch = WebAssemblyISD::CALL 0x37d3000, 0x37d2db0 [ORD=2] 
                                                                                                                                                 
                                                                               0x37d3128: <multiple use>                                         
      0x2e16db8: <multiple use>                                                0x37d2ed8: <multiple use>                                         
    0x2e17130: ch,glue = callseq_end 0x2e16ee0, 0x2e16db8, 0x2e16db8 [O        0x37d2ed8: <multiple use>                                         
RD=2]                                                                                                                                            
                                                                             0x37d3250: ch,glue = callseq_end 0x37d3128:1, 0x37d2ed8, 0x37d2ed8  
                                                                         [ORD=2]                                                                 
                                                                                                                                                 
                                                                             0x37d3128: <multiple use>                                           
  0x2e17258: ch = WebAssemblyISD::RETURN 0x2e17130 [ORD=3]                 0x37d3378: ch = WebAssemblyISD::RETURN 0x37d3250, 0x37d3128 [ORD=3]   
                                                                                                                                                 
                                                                                                                                                 
                                                                                                                                                 
Combining: 0x2e17258: ch = WebAssemblyISD::RETURN 0x2e17130 [ORD=3]      Combining: 0x37d3378: ch = WebAssemblyISD::RETURN 0x37d3250, 0x37d3128  
                                                                         [ORD=3]                                                                 
                                                                                                                                                 
Combining: 0x2e17130: ch,glue = callseq_end 0x2e16ee0, 0x2e16db8, 0x2e1  Combining: 0x37d3250: ch,glue = callseq_end 0x37d3128:1, 0x37d2ed8, 0x3 
6db8 [ORD=2]                                                             7d2ed8 [ORD=2]                                                          
                                                                                                                                                 
                                                                         Combining: 0x37d3128: i32,ch = WebAssemblyISD::CALL 0x37d3000, 0x37d2db 
                                                                         0 [ORD=2]                                                               
                                                                                                                                                 
Combining: 0x2e16ee0: ch,glue = callseq_start 0x2de2880, 0x2e16db8 [ORD  Combining: 0x37d3000: ch,glue = callseq_start 0x379e9a0, 0x37d2ed8 [ORD 
=2]                                                                      =2]                                                                     
                                                                                                                                                 
Combining: 0x2e16db8: i32 = TargetConstant<0>                            Combining: 0x37d2ed8: i32 = TargetConstant<0>                           
                                                                                                                                                 
                                                                         Combining: 0x37d2db0: i32 = GlobalAddress<i32 ()* @i32_nullary> 0 [ORD= 
                                                                         2]                                                                      
                                                                                                                                                 
Combining: 0x2de2880: ch = EntryToken                                    Combining: 0x379e9a0: ch = EntryToken

I do set hasSideEffects = 1 on calls, so that's unexpected!

[jfb]

• Fix comment.

[sunfish]

Not done reviewing, but here are some comments so far.

lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

136 ↗

(On Diff #32763)

Is this a mismatched quote?

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

216 ↗

(On Diff #32763)

This is likely why the call_void is getting deleted. It's necessary to hook up the Chain result even when there is no return value.

321 ↗

(On Diff #32763)

We should implement isOffsetFoldingLegal() to always return false, and then we can change this to assert that the offset is 0.

323 ↗

(On Diff #32763)

TargetFlags will only get set if the target sets them, and since we don't set them, this won't happen, so we can assert this too.

lib/Target/WebAssembly/WebAssemblyISelLowering.h

30 ↗

(On Diff #32763)

Given the preprocessor magic, this comment should move to WebAssemblyISD.def.

lib/Target/WebAssembly/WebAssemblyInstrCall.td

22 ↗

(On Diff #32763)

If we're going to use Pseudo instructions, should implement expandPostRAPseudo to expand them.

24 ↗

(On Diff #32763)

It looks like it's not necessary to set hasSideEffects on call instructions.

lib/Target/WebAssembly/WebAssemblyInstrInfo.td

50 ↗

(On Diff #32763)

It looks like it's not necessary to set SDNPSideEffect here either.

53 ↗

(On Diff #32763)

Ditto about SDNPSideEffect.

58 ↗

(On Diff #32763)

For that matter, we shouldn't need it on WebAssemblyreturn either.

[jfb]

• toSymbol
• Move NodeType comment to .def file.
• Fix chain. Remove CALL_VOID for now.
• Implement isOffsetFoldingLegal, assert on getOffset and getTargetFlags.
• Remove side-effect from call.
• Remove side-effect from return.
• Change symbol character from ` to $.

lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

136 ↗

(On Diff #32763)

Nah, just a marker for symbols. The discussion was still ongoing, but it looks like things settled on $ instead.
I'll factor it out into a toSymbol function.

lib/Target/WebAssembly/WebAssemblyInstrCall.td

22 ↗

(On Diff #32763)

BPF doesn't have it and aarch64 ignores callseq in expandPostRAPseudo, but both use pseudos. I'm not sure I understand what our current implementation would do beyond returning false, but then again I'm still pretty confused by selection DAG. Do you think this patch should have expandPostRAPseudo, and if so in what form?

[jfb]

test/CodeGen/WebAssembly/call.ll

23 ↗

(On Diff #32848)

This is resolved, but there's now an issue with void functions which I'll tackle in a separate patch.

[jfb]

• Use a multiclass.

[• sunfishcode]

lib/Target/WebAssembly/WebAssemblyInstrCall.td

22 ↗

(On Diff #32851)

If we don't need post-RA expansion, then these can just be regular instructions, rather than Pseudos. You can set 'isCodeGenOnly = 1' for them to indicate that they're just compiler magic.

[jfb]

• Fix comment.
• toSymbol
• Move NodeType comment to .def file.
• Fix chain. Remove CALL_VOID for now.
• Implement isOffsetFoldingLegal, assert on getOffset and getTargetFlags.
• Remove side-effect from call.
• Remove side-effect from return.
• Change symbol character from ` to $.
• Use a multiclass.
• Make callseq an instruction instead of a pseudo.

[jfb]

[jfb]

Merge.

llvm/trunk/lib/Target/WebAssembly/InstPrinter/WebAssemblyInstPrinter.h

 public:
   WebAssemblyInstPrinter(const MCAsmInfo &MAI, const MCInstrInfo &MII,
                          const MCRegisterInfo &MRI);
 
   void printRegName(raw_ostream &OS, unsigned RegNo) const override;
   void printInst(const MCInst *MI, raw_ostream &OS, StringRef Annot,
                  const MCSubtargetInfo &STI) override;
 
+  // Used by tblegen code.
+  void printOperand(const MCInst *MI, unsigned OpNo, raw_ostream &O);
+
   // Autogenerated by tblgen.
   void printInstruction(const MCInst *MI, raw_ostream &O);
   static const char *getRegisterName(unsigned RegNo);
 };
 
 } // end namespace llvm
 
 #endif

llvm/trunk/lib/Target/WebAssembly/InstPrinter/WebAssemblyInstPrinter.cpp

 }
 
 void WebAssemblyInstPrinter::printInst(const MCInst *MI, raw_ostream &OS,
                                        StringRef Annot,
                                        const MCSubtargetInfo &STI) {
   printInstruction(MI, OS);
   printAnnotation(OS, Annot);
 }
+
+void WebAssemblyInstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
+                                          raw_ostream &O) {
+  const MCOperand &Op = MI->getOperand(OpNo);
+  if (Op.isReg())
+    O << getRegisterName(Op.getReg());
+  else if (Op.isImm())
+    O << '#' << Op.getImm();
+  else {
+    assert(Op.isExpr() && "unknown operand kind in printOperand");
+    Op.getExpr()->print(O, &MAI);
+  }
+}

llvm/trunk/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

 static SmallString<32> Name(const WebAssemblyInstrInfo *TII,
                             const MachineInstr *MI) {
   std::string N(StringRef(TII->getName(MI->getOpcode())).lower());
   std::string::size_type End = N.rfind('_');
   End = std::string::npos == End ? N.length() : End;
   return SmallString<32>(&N[0], &N[End]);
 }
 
+static std::string toSymbol(StringRef S) { return ("$" + S).str(); }
+
 void WebAssemblyAsmPrinter::EmitInstruction(const MachineInstr *MI) {
+  DEBUG(dbgs() << "EmitInstruction: " << *MI << '\n');
   SmallString<128> Str;
   raw_svector_ostream OS(Str);
 
   unsigned NumDefs = MI->getDesc().getNumDefs();
   assert(NumDefs <= 1 &&
          "Instructions with multiple result values not implemented");
 
   OS << '\t';
case MachineOperand::MO_FPImmediate: {
       auto Written =
           FP.convertToHexString(buf, /*hexDigits=*/0, /*upperCase=*/false,
                                 APFloat::rmNearestTiesToEven);
       (void)Written;
       assert(Written != 0);
       assert(Written < BufBytes);
       OS << ' ' << buf;
     } break;
+    case MachineOperand::MO_GlobalAddress: {
+      OS << ' ' << toSymbol(MO.getGlobal()->getName());
+    } break;
     }
   OS << ')';
 
   if (NumDefs != 0)
     OS << ')';
 
   OS << '\n';
 
   OutStreamer->EmitRawText(OS.str());
 }
 
 // Force static initialization.
 extern "C" void LLVMInitializeWebAssemblyAsmPrinter() {
   RegisterAsmPrinter<WebAssemblyAsmPrinter> X(TheWebAssemblyTarget32);
   RegisterAsmPrinter<WebAssemblyAsmPrinter> Y(TheWebAssemblyTarget64);
 }

llvm/trunk/lib/Target/WebAssembly/WebAssemblyISD.def

+//- WebAssemblyISD.def - WebAssembly ISD ---------------------------*- C++ -*-//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file describes the various WebAssembly ISD node types.
+///
+//===----------------------------------------------------------------------===//
+
+// NOTE: NO INCLUDE GUARD DESIRED!
+
+HANDLE_NODETYPE(CALL)
+HANDLE_NODETYPE(RETURN)
+HANDLE_NODETYPE(ARGUMENT)
+HANDLE_NODETYPE(Wrapper)
+
+// add memory opcodes starting at ISD::FIRST_TARGET_MEMORY_OPCODE here...

llvm/trunk/lib/Target/WebAssembly/WebAssemblyISelLowering.h

 #include "llvm/Target/TargetLowering.h"
 
 namespace llvm {
 
 namespace WebAssemblyISD {
 
 enum NodeType : unsigned {
   FIRST_NUMBER = ISD::BUILTIN_OP_END,
-  RETURN,
-  ARGUMENT,
-
-  // add memory opcodes starting at ISD::FIRST_TARGET_MEMORY_OPCODE here...
+#define HANDLE_NODETYPE(NODE) NODE,
+#include "WebAssemblyISD.def"
+#undef HANDLE_NODETYPE
 };
 
 } // end namespace WebAssemblyISD
 
 class WebAssemblySubtarget;
 class WebAssemblyTargetMachine;
 
 class WebAssemblyTargetLowering final : public TargetLowering {
 public:
   WebAssemblyTargetLowering(const TargetMachine &TM,
                             const WebAssemblySubtarget &STI);
 
 private:
   /// Keep a pointer to the WebAssemblySubtarget around so that we can make the
   /// right decision when generating code for different targets.
   const WebAssemblySubtarget *Subtarget;
 
   FastISel *createFastISel(FunctionLoweringInfo &FuncInfo,
                            const TargetLibraryInfo *LibInfo) const override;
-
+  bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override;
   MVT getScalarShiftAmountTy(const DataLayout &DL, EVT) const override;
-
   const char *getTargetNodeName(unsigned Opcode) const override;
 
+  SDValue LowerCall(CallLoweringInfo &CLI,
+                    SmallVectorImpl<SDValue> &InVals) const override;
   bool CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF,
                       bool isVarArg,
                       const SmallVectorImpl<ISD::OutputArg> &Outs,
                       LLVMContext &Context) const override;
-
   SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
                       const SmallVectorImpl<ISD::OutputArg> &Outs,
                       const SmallVectorImpl<SDValue> &OutVals, SDLoc dl,
                       SelectionDAG &DAG) const override;
-
   SDValue LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv,
                                bool IsVarArg,
                                const SmallVectorImpl<ISD::InputArg> &Ins,
                                SDLoc DL, SelectionDAG &DAG,
                                SmallVectorImpl<SDValue> &InVals) const override;
+
+  // Custom lowering hooks.
+  SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
+  SDValue LowerGlobalAddress(SDValue Op, SelectionDAG &DAG) const;
 };
 
 namespace WebAssembly {
 FastISel *createFastISel(FunctionLoweringInfo &funcInfo,
                          const TargetLibraryInfo *libInfo);
 } // end namespace WebAssembly
 
 } // end namespace llvm
 
 #endif

llvm/trunk/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

 
 #include "WebAssemblyISelLowering.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
 #include "WebAssemblyMachineFunctionInfo.h"
 #include "WebAssemblySubtarget.h"
 #include "WebAssemblyTargetMachine.h"
 #include "WebAssemblyTargetObjectFile.h"
 #include "llvm/CodeGen/Analysis.h"
+#include "llvm/CodeGen/CallingConvLower.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/SelectionDAG.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"

 };
 
 int DiagnosticInfoUnsupported::KindID = 0;
 } // end anonymous namespace
 
 WebAssemblyTargetLowering::WebAssemblyTargetLowering(
     const TargetMachine &TM, const WebAssemblySubtarget &STI)
     : TargetLowering(TM), Subtarget(&STI) {
+  auto MVTPtr = Subtarget->hasAddr64() ? MVT::i64 : MVT::i32;
+
   // Booleans always contain 0 or 1.
   setBooleanContents(ZeroOrOneBooleanContent);
   // WebAssembly does not produce floating-point exceptions on normal floating
   // point operations.
   setHasFloatingPointExceptions(false);
   // We don't know the microarchitecture here, so just reduce register pressure.
   setSchedulingPreference(Sched::RegPressure);
   // Tell ISel that we have a stack pointer.
   setStackPointerRegisterToSaveRestore(
       Subtarget->hasAddr64() ? WebAssembly::SP64 : WebAssembly::SP32);
   // Set up the register classes.
   addRegisterClass(MVT::i32, &WebAssembly::Int32RegClass);
   addRegisterClass(MVT::i64, &WebAssembly::Int64RegClass);
   addRegisterClass(MVT::f32, &WebAssembly::Float32RegClass);
   addRegisterClass(MVT::f64, &WebAssembly::Float64RegClass);
   // Compute derived properties from the register classes.
   computeRegisterProperties(Subtarget->getRegisterInfo());
 
   // FIXME: many setOperationAction are missing...
 
+  setOperationAction(ISD::GlobalAddress, MVTPtr, Custom);
+
   for (auto T : {MVT::f32, MVT::f64}) {
     // Don't expand the floating-point types to constant pools.
     setOperationAction(ISD::ConstantFP, T, Legal);
     // Expand floating-point comparisons.
     for (auto CC : {ISD::SETO, ISD::SETUO, ISD::SETUEQ, ISD::SETONE,
                     ISD::SETULT, ISD::SETULE, ISD::SETUGT, ISD::SETUGE})
       setCondCodeAction(CC, T, Expand);
     // Expand floating-point library function operators.
WebAssemblyTargetLowering::WebAssemblyTargetLowering(
   setOperationAction(ISD::DYNAMIC_STACKALLOC, MVT::i32, Expand);
 }
 
 FastISel *WebAssemblyTargetLowering::createFastISel(
     FunctionLoweringInfo &FuncInfo, const TargetLibraryInfo *LibInfo) const {
   return WebAssembly::createFastISel(FuncInfo, LibInfo);
 }
 
+bool WebAssemblyTargetLowering::isOffsetFoldingLegal(
+    const GlobalAddressSDNode *GA) const {
+  // The WebAssembly target doesn't support folding offsets into global
+  // addresses.
+  return false;
+}
+
 MVT WebAssemblyTargetLowering::getScalarShiftAmountTy(const DataLayout &DL,
                                                       EVT VT) const {
   return VT.getSimpleVT();
 }
 
 const char *
 WebAssemblyTargetLowering::getTargetNodeName(unsigned Opcode) const {
   switch (static_cast<WebAssemblyISD::NodeType>(Opcode)) {
-  case WebAssemblyISD::FIRST_NUMBER: break;
-  case WebAssemblyISD::RETURN: return "WebAssemblyISD::RETURN";
-  case WebAssemblyISD::ARGUMENT: return "WebAssemblyISD::ARGUMENT";
+  case WebAssemblyISD::FIRST_NUMBER:
+    break;
+#define HANDLE_NODETYPE(NODE)                                                  \
+  case WebAssemblyISD::NODE:                                                   \
+    return "WebAssemblyISD::" #NODE;
+#include "WebAssemblyISD.def"
+#undef HANDLE_NODETYPE
   }
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // WebAssembly Lowering private implementation.
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Lowering Code
 //===----------------------------------------------------------------------===//
 
 static void fail(SDLoc DL, SelectionDAG &DAG, const char *msg) {
   MachineFunction &MF = DAG.getMachineFunction();
   DAG.getContext()->diagnose(
       DiagnosticInfoUnsupported(DL, *MF.getFunction(), msg, SDValue()));
 }
 
-<<<<<<< HEAD
 SDValue
 WebAssemblyTargetLowering::LowerCall(CallLoweringInfo &CLI,
                                      SmallVectorImpl<SDValue> &InVals) const {
   SelectionDAG &DAG = CLI.DAG;
   SDLoc DL = CLI.DL;
   SDValue Chain = CLI.Chain;
   SDValue Callee = CLI.Callee;
   MachineFunction &MF = DAG.getMachineFunction();
 
   CallingConv::ID CallConv = CLI.CallConv;
   if (CallConv != CallingConv::C)
     fail(DL, DAG, "WebAssembly doesn't support non-C calling conventions");
   if (CLI.IsTailCall || MF.getTarget().Options.GuaranteedTailCallOpt)
     fail(DL, DAG, "WebAssembly doesn't support tail call yet");
   if (CLI.IsPatchPoint)
     fail(DL, DAG, "WebAssembly doesn't support patch point yet");
 
   SmallVectorImpl<ISD::OutputArg> &Outs = CLI.Outs;
   SmallVectorImpl<SDValue> &OutVals = CLI.OutVals;
-  Type *retTy = CLI.RetTy;
   bool IsStructRet = (Outs.empty()) ? false : Outs[0].Flags.isSRet();
   if (IsStructRet)
     fail(DL, DAG, "WebAssembly doesn't support struct return yet");
   if (Outs.size() > 1)
     fail(DL, DAG, "WebAssembly doesn't support more than 1 returned value yet");
 
   SmallVectorImpl<ISD::InputArg> &Ins = CLI.Ins;
-  ArgListTy &Args = CLI.getArgs();
   bool IsVarArg = CLI.IsVarArg;
   if (IsVarArg)
     fail(DL, DAG, "WebAssembly doesn't support varargs yet");
   // Analyze operands of the call, assigning locations to each operand.
   SmallVector<CCValAssign, 16> ArgLocs;
   CCState CCInfo(CallConv, IsVarArg, MF, ArgLocs, *DAG.getContext());
   unsigned NumBytes = CCInfo.getNextStackOffset();
 
   auto PtrVT = getPointerTy(MF.getDataLayout());
-  auto Zero = DAG.getConstant(0, CLI.DL, PtrVT, true);
-  auto NB = DAG.getConstant(NumBytes, CLI.DL, PtrVT, true);
-  Chain = DAG.getCALLSEQ_START(Chain, NB, CLI.DL);
+  auto Zero = DAG.getConstant(0, DL, PtrVT, true);
+  auto NB = DAG.getConstant(NumBytes, DL, PtrVT, true);
+  Chain = DAG.getCALLSEQ_START(Chain, NB, DL);
 
   SmallVector<SDValue, 16> Ops;
   Ops.push_back(Chain);
-  Ops.push_back(CLI.Callee);
-  Ops.append(CLI.OutVals.begin(), CLI.OutVals.end());
+  Ops.push_back(Callee);
+  Ops.append(OutVals.begin(), OutVals.end());
 
   SmallVector<EVT, 8> Tys;
-  for (const auto &In : CLI.Ins)
+  for (const auto &In : Ins)
     Tys.push_back(In.VT);
   Tys.push_back(MVT::Other);
-  SDVTList TyList = CLI.DAG.getVTList(Tys);
-  SDValue Res = CLI.DAG.getNode(WebAssemblyISD::CALL, CLI.DL, TyList, Ops);
+  SDVTList TyList = DAG.getVTList(Tys);
+  SDValue Res = DAG.getNode(WebAssemblyISD::CALL, DL, TyList, Ops);
+  if (Ins.empty()) {
+    Chain = Res;
+  } else {
     InVals.push_back(Res);
     Chain = Res.getValue(1);
+  }
 
   // FIXME: handle CLI.RetSExt and CLI.RetZExt?
 
-  Chain = CLI.DAG.getCALLSEQ_END(Chain, NB, Zero, SDValue(), CLI.DL);
+  Chain = DAG.getCALLSEQ_END(Chain, NB, Zero, SDValue(), DL);
 
   return Chain;
 }
 
-=======
->>>>>>> parent of 03685a9... call
 bool WebAssemblyTargetLowering::CanLowerReturn(
     CallingConv::ID CallConv, MachineFunction &MF, bool IsVarArg,
     const SmallVectorImpl<ISD::OutputArg> &Outs, LLVMContext &Context) const {
   // WebAssembly can't currently handle returning tuples.
   return Outs.size() <= 1;
 }
 
 SDValue WebAssemblyTargetLowering::LowerReturn(
InVals.push_back(
             : DAG.getNode(ISD::UNDEF, DL, In.VT));
     ++ArgNo;
   }
 
   return Chain;
 }
 
 //===----------------------------------------------------------------------===//
-//  Other Lowering Code
+//  Custom lowering hooks.
 //===----------------------------------------------------------------------===//
 
+SDValue WebAssemblyTargetLowering::LowerOperation(SDValue Op,
+                                                  SelectionDAG &DAG) const {
+  switch (Op.getOpcode()) {
+  default:
+    llvm_unreachable("unimplemented operation lowering");
+    return SDValue();
+  case ISD::GlobalAddress:
+    return LowerGlobalAddress(Op, DAG);
+  }
+}
+
+SDValue WebAssemblyTargetLowering::LowerGlobalAddress(SDValue Op,
+                                                      SelectionDAG &DAG) const {
+  SDLoc DL(Op);
+  const auto *GA = cast<GlobalAddressSDNode>(Op);
+  EVT VT = Op.getValueType();
+  assert(GA->getOffset() == 0 &&
+         "offsets on global addresses are forbidden by isOffsetFoldingLegal");
+  assert(GA->getTargetFlags() == 0 && "WebAssembly doesn't set target flags");
+  if (GA->getAddressSpace() != 0)
+    fail(DL, DAG, "WebAssembly only expects the 0 address space");
+  return DAG.getNode(WebAssemblyISD::Wrapper, DL, VT,
+                     DAG.getTargetGlobalAddress(GA->getGlobal(), DL, VT));
+}
+
 //===----------------------------------------------------------------------===//
 //                          WebAssembly Optimization Hooks
 //===----------------------------------------------------------------------===//
 
 MCSection *WebAssemblyTargetObjectFile::SelectSectionForGlobal(
     const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
     const TargetMachine &TM) const {
   return getDataSection();
 }

llvm/trunk/lib/Target/WebAssembly/WebAssemblyInstrCall.td

 //===- WebAssemblyInstrCall.td-WebAssembly Call codegen support -*- tablegen -*-
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief WebAssembly Call operand code-gen constructs.
 ///
 //===----------------------------------------------------------------------===//
 
+// The call sequence start/end LLVM-isms isn't useful to WebAssembly since it's
+// a virtual ISA.
+let isCodeGenOnly = 1 in {
+def : I<(outs), (ins i64imm:$amt),
+        [(WebAssemblycallseq_start timm:$amt)]>;
+def : I<(outs), (ins i64imm:$amt1, i64imm:$amt2),
+        [(WebAssemblycallseq_end timm:$amt1, timm:$amt2)]>;
+} // isCodeGenOnly = 1
+
+multiclass CALL<WebAssemblyRegClass vt> {
+  def CALL_#vt : I<(outs vt:$dst), (ins Int32:$callee, variable_ops),
+                   [(set vt:$dst, (WebAssemblycall Int32:$callee))]>;
+}
+let Uses = [SP32, SP64], isCall = 1 in {
+  defm : CALL<Int32>;
+  defm : CALL<Int64>;
+  defm : CALL<Float32>;
+  defm : CALL<Float64>;
+  // FIXME: void.
+} // Uses = [SP32,SP64], isCall = 1
+
 /*
  * TODO(jfb): Add the following.
  *
  * call_direct: call function directly
  * call_indirect: call function indirectly
  * addressof: obtain a function pointer value for a given function
  */

llvm/trunk/lib/Target/WebAssembly/WebAssemblyInstrControl.td

  * continue: continue to start of nested loop
  * break: break to end from nested loop or block
  * switch: switch statement with fallthrough
  */
 
 multiclass RETURN<WebAssemblyRegClass vt> {
   def RETURN_#vt : I<(outs), (ins vt:$val), [(WebAssemblyreturn vt:$val)]>;
 }
-let hasSideEffects = 1, isReturn = 1, isTerminator = 1, hasCtrlDep = 1,
-    isBarrier = 1 in {
+let isReturn = 1, isTerminator = 1, hasCtrlDep = 1, isBarrier = 1 in {
   defm : RETURN<Int32>;
   defm : RETURN<Int64>;
   defm : RETURN<Float32>;
   defm : RETURN<Float64>;
   def RETURN_VOID : I<(outs), (ins), [(WebAssemblyreturn)]>;
-} // hasSideEffects = 1, isReturn = 1, isTerminator = 1, hasCtrlDep = 1,
-  // isBarrier = 1
+} // isReturn = 1, isTerminator = 1, hasCtrlDep = 1, isBarrier = 1

llvm/trunk/lib/Target/WebAssembly/WebAssemblyInstrFormats.td

 // WebAssemblyInstrFormats.td - WebAssembly Instruction Formats -*- tblgen -*-//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief WebAssembly instruction format definitions.
 ///
 //===----------------------------------------------------------------------===//
 
-// WebAssembly Instruction Format
+// WebAssembly Instruction Format.
 class WebAssemblyInst<string cstr> : Instruction {
   field bits<0> Inst; // Instruction encoding.
   let Namespace   = "WebAssembly";
   let Pattern     = [];
   let Constraints = cstr;
 }
 
-// Normal instructions
+// Normal instructions.
 class I<dag oops, dag iops, list<dag> pattern, string cstr = "">
     : WebAssemblyInst<cstr> {
   dag OutOperandList = oops;
   dag InOperandList  = iops;
   let Pattern        = pattern;
 }
 
 // Unary and binary instructions, for the local types that WebAssembly supports.

llvm/trunk/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

 def HasAddr64 : Predicate<"Subtarget->hasAddr64()">;
 def HasSIMD128 : Predicate<"Subtarget->hasSIMD128()">,
                            AssemblerPredicate<"FeatureSIMD128", "simd128">;
 
 //===----------------------------------------------------------------------===//
 // WebAssembly-specific DAG Node Types.
 //===----------------------------------------------------------------------===//
 
+def SDT_WebAssemblyCallSeqStart : SDCallSeqStart<[SDTCisVT<0, iPTR>]>;
+def SDT_WebAssemblyCallSeqEnd :
+    SDCallSeqEnd<[SDTCisVT<0, iPTR>, SDTCisVT<1, iPTR>]>;
+def SDT_WebAssemblyCall     : SDTypeProfile<1, -1, [SDTCisPtrTy<1>]>;
 def SDT_WebAssemblyArgument : SDTypeProfile<1, 1, [SDTCisVT<1, i32>]>;
 def SDT_WebAssemblyReturn   : SDTypeProfile<0, -1, []>;
+def SDT_WebAssemblyWrapper  : SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>,
+                                                   SDTCisPtrTy<0>]>;
 
 //===----------------------------------------------------------------------===//
 // WebAssembly-specific DAG Nodes.
 //===----------------------------------------------------------------------===//
 
+def WebAssemblycallseq_start :
+    SDNode<"ISD::CALLSEQ_START", SDT_WebAssemblyCallSeqStart,
+           [SDNPHasChain, SDNPOutGlue]>;
+def WebAssemblycallseq_end :
+    SDNode<"ISD::CALLSEQ_END", SDT_WebAssemblyCallSeqEnd,
+           [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
+def WebAssemblycall      : SDNode<"WebAssemblyISD::CALL",
+                                  SDT_WebAssemblyCall,
+                                  [SDNPHasChain, SDNPVariadic]>;
 def WebAssemblyargument : SDNode<"WebAssemblyISD::ARGUMENT",
                                  SDT_WebAssemblyArgument>;
 def WebAssemblyreturn   : SDNode<"WebAssemblyISD::RETURN",
-                                 SDT_WebAssemblyReturn,
-                                 [SDNPHasChain, SDNPSideEffect]>;
+                                 SDT_WebAssemblyReturn, [SDNPHasChain]>;
+def WebAssemblywrapper  : SDNode<"WebAssemblyISD::Wrapper",
+                                 SDT_WebAssemblyWrapper>;
 
 //===----------------------------------------------------------------------===//
 // WebAssembly-specific Operands.
 //===----------------------------------------------------------------------===//
 
 /*
  * TODO(jfb): Add the following.
  *
  * get_local: read the current value of a local variable
  * set_local: set the current value of a local variable
 */
 
+def global : Operand<iPTR>;
+
 //===----------------------------------------------------------------------===//
 // WebAssembly Instruction Format Definitions.
 //===----------------------------------------------------------------------===//
 
 include "WebAssemblyInstrFormats.td"
 
 multiclass ARGUMENT<WebAssemblyRegClass vt> {
   def ARGUMENT_#vt : I<(outs vt:$res), (ins i32imm:$argno),
def Immediate_I32 : I<(outs Int32:$res), (ins i32imm:$imm),
                       [(set Int32:$res, imm:$imm)]>;
 def Immediate_I64 : I<(outs Int64:$res), (ins i64imm:$imm),
                       [(set Int64:$res, imm:$imm)]>;
 def Immediate_F32 : I<(outs Float32:$res), (ins f32imm:$imm),
                       [(set Float32:$res, fpimm:$imm)]>;
 def Immediate_F64 : I<(outs Float64:$res), (ins f64imm:$imm),
                       [(set Float64:$res, fpimm:$imm)]>;
 
+// Special types of immediates.
+def GLOBAL : I<(outs Int32:$dst), (ins global:$addr),
+               [(set Int32:$dst, (WebAssemblywrapper tglobaladdr:$addr))]>;
+
 //===----------------------------------------------------------------------===//
 // Additional sets of instructions.
 //===----------------------------------------------------------------------===//
 
 include "WebAssemblyInstrMemory.td"
 include "WebAssemblyInstrCall.td"
 include "WebAssemblyInstrControl.td"
 include "WebAssemblyInstrInteger.td"
 include "WebAssemblyInstrFloat.td"
 include "WebAssemblyInstrConv.td"
 include "WebAssemblyInstrAtomics.td"
 include "WebAssemblyInstrSIMD.td"

llvm/trunk/test/CodeGen/WebAssembly/call.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that basic call operations assemble as expected.
 
 target datalayout = "e-p:32:32-i64:64-v128:8:128-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
-declare void @nullary()
+declare i32 @i32_nullary()
+declare i32 @i32_unary(i32)
+declare i64 @i64_nullary()
+declare float @float_nullary()
+declare double @double_nullary()
+
+; CHECK-LABEL: call_i32_nullary:
+; CHECK-NEXT: (setlocal @0 (global $i32_nullary))
+; CHECK-NEXT: (setlocal @1 (call @0))
+; CHECK-NEXT: (return @1)
+define i32 @call_i32_nullary() {
+  %r = call i32 @i32_nullary()
+  ret i32 %r
+}
+
+; CHECK-LABEL: call_i64_nullary:
+; CHECK-NEXT: (setlocal @0 (global $i64_nullary))
+; CHECK-NEXT: (setlocal @1 (call @0))
+; CHECK-NEXT: (return @1)
+define i64 @call_i64_nullary() {
+  %r = call i64 @i64_nullary()
+  ret i64 %r
+}
 
-; CHECK-LABEL: call_nullary:
-; CHECK-NEXT: (call @foo)
-; CHECK-NEXT: (return)
-define void @call_nullary() {
-  call void @nullary()
-  ret void
+; CHECK-LABEL: call_float_nullary:
+; CHECK-NEXT: (setlocal @0 (global $float_nullary))
+; CHECK-NEXT: (setlocal @1 (call @0))
+; CHECK-NEXT: (return @1)
+define float @call_float_nullary() {
+  %r = call float @float_nullary()
+  ret float %r
 }
 
+; CHECK-LABEL: call_double_nullary:
+; CHECK-NEXT: (setlocal @0 (global $double_nullary))
+; CHECK-NEXT: (setlocal @1 (call @0))
+; CHECK-NEXT: (return @1)
+define double @call_double_nullary() {
+  %r = call double @double_nullary()
+  ret double %r
+}
+
+; CHECK-LABEL: call_i32_unary:
+; CHECK-NEXT: (setlocal @0 (argument 0))
+; CHECK-NEXT: (setlocal @1 (global $i32_unary))
+; CHECK-NEXT: (setlocal @2 (call @1 @0))
+; CHECK-NEXT: (return @2)
+define i32 @call_i32_unary(i32 %a) {
+  %r = call i32 @i32_unary(i32 %a)
+  ret i32 %r
+}
 
-; tail call
-; multiple args
-; interesting returns (int, float, struct, multiple)
-; vararg
+; FIXME test the following:
+;  - Functions without return.
+;  - More argument combinations.
+;  - Tail call.
+;  - Interesting returns (struct, multiple).
+;  - Vararg.