Revert two bad commits.

[jfb]

Summary

I forgot to squash git commits before doing an svn dcommit of D12219. Reverting, and re-submitting.

[llvm-commits]

Generally we try not to send out code reviews unless there's an expectation
that review is required/desired.

Seeing something sent for review, then committed without any sign off can
be problematic. (some people send things for review then say things like
"if no one says anything bad about this in <time period> I'll commit" which
is generally seen as poor form - either it needs review, in which case time
doesn't change that fact, or it doesn't & shouldn't be sent for review in
the first place)

• msg-876-179.txt162 BDownload

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]);
 }
 
 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';

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)

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,
-#define HANDLE_NODETYPE(NODE) NODE,
-#include "WebAssemblyISD.def"
-#undef HANDLE_NODETYPE
+  RETURN,
+  ARGUMENT,
+
   // add memory opcodes starting at ISD::FIRST_TARGET_MEMORY_OPCODE here...
 };
 
 } // end namespace WebAssemblyISD
 
 class WebAssemblySubtarget;
 class WebAssemblyTargetMachine;
 
private:
 
   FastISel *createFastISel(FunctionLoweringInfo &FuncInfo,
                            const TargetLibraryInfo *LibInfo) 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,

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"

 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;
-#define HANDLE_NODETYPE(NODE)                                                  \
-  case WebAssemblyISD::NODE:                                                   \
-    return "WebAssemblyISD::" #NODE;
-#include "WebAssemblyISD.def"
-#undef HANDLE_NODETYPE
+  case WebAssemblyISD::FIRST_NUMBER: break;
+  case WebAssemblyISD::RETURN: return "WebAssemblyISD::RETURN";
+  case WebAssemblyISD::ARGUMENT: return "WebAssemblyISD::ARGUMENT";
   }
   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, DL, PtrVT, true);
-  auto NB = DAG.getConstant(NumBytes, DL, PtrVT, true);
-  Chain = DAG.getCALLSEQ_START(Chain, NB, DL);
+  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);
 
   SmallVector<SDValue, 16> Ops;
   Ops.push_back(Chain);
-  Ops.push_back(Callee);
-  Ops.append(OutVals.begin(), OutVals.end());
+  Ops.push_back(CLI.Callee);
+  Ops.append(CLI.OutVals.begin(), CLI.OutVals.end());
 
   SmallVector<EVT, 8> Tys;
-  for (const auto &In : Ins)
+  for (const auto &In : CLI.Ins)
     Tys.push_back(In.VT);
   Tys.push_back(MVT::Other);
-  SDVTList TyList = DAG.getVTList(Tys);
-  SDValue Res = DAG.getNode(WebAssemblyISD::CALL, DL, TyList, Ops);
-  if (!Ins.empty()) {
-    InVals.push_back(Res);
-    Chain = Res.getValue(1);
-  }
+  SDVTList TyList = CLI.DAG.getVTList(Tys);
+  SDValue Res = CLI.DAG.getNode(WebAssemblyISD::CALL, CLI.DL, TyList, Ops);
 
   // FIXME: handle CLI.RetSExt and CLI.RetZExt?
 
-  Chain = DAG.getCALLSEQ_END(Chain, NB, Zero, SDValue(), DL);
+  Chain = CLI.DAG.getCALLSEQ_END(Chain, NB, Zero, SDValue(), CLI.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(

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.
-
-// FIXME make noop?
-//def : Pat<(WebAssemblycallseq_start timm), (i32 (IMPLICIT_DEF))>;
-//def : Pat<(WebAssemblycallseq_end timm, timm), (i32 (IMPLICIT_DEF))>;
-
-def SDT_WebAssemblyCallSeqStart : SDCallSeqStart<[SDTCisVT<0, iPTR>]>;
-def SDT_WebAssemblyCallSeqEnd :
-    SDCallSeqEnd<[SDTCisVT<0, iPTR>, SDTCisVT<1, iPTR>]>;
-def WebAssemblycallseq_start :
-    SDNode<"ISD::CALLSEQ_START", SDT_WebAssemblyCallSeqStart,
-           [SDNPHasChain, SDNPOutGlue]>;
-def WebAssemblycallseq_end :
-    SDNode<"ISD::CALLSEQ_END", SDT_WebAssemblyCallSeqEnd,
-           [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
-def : Pseudo<(outs), (ins i64imm:$amt),
-             [(WebAssemblycallseq_start timm:$amt)],
-             "#ADJCALLSTACKDOWN $amt">;
-def : Pseudo<(outs), (ins i64imm:$amt1, i64imm:$amt2),
-             [(WebAssemblycallseq_end timm:$amt1, timm:$amt2)],
-       "#ADJCALLSTACKUP $amt1 $amt2">;
-
 /*
  * 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/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;
 }
 
-// Pseudo instructions.
-class Pseudo<dag oops, dag iops, list<dag> pattern, string asmstr,
-             string cstr = "">
-  : I<oops, iops, pattern, cstr> {
-  let isPseudo  = 1;
-  let AsmString = asmstr;
-}
-
 // Unary and binary instructions, for the local types that WebAssembly supports.
 multiclass UnaryInt<SDNode node> {
   def _I32 : I<(outs Int32:$dst), (ins Int32:$src),
                [(set Int32:$dst, (node Int32:$src))]>;
   def _I64 : I<(outs Int64:$dst), (ins Int64:$src),
                [(set Int64:$dst, (node Int64:$src))]>;
 }
 multiclass BinaryInt<SDNode node> {

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 @void_nullary()
-declare void @int32_nullary()
+declare void @nullary()
 
-; CHECK-LABEL: call_void_nullary:
+; CHECK-LABEL: call_nullary:
 ; CHECK-NEXT: (call @foo)
 ; CHECK-NEXT: (return)
-define void @call_void_nullary() {
-  call void @void_nullary()
+define void @call_nullary() {
+  call void @nullary()
   ret void
 }
 
 
 ; tail call
 ; multiple args
 ; interesting returns (int, float, struct, multiple)
 ; vararg