[WebAssembly] Use the new offset syntax for memory operands in inline asm.

[oota-llvm.git] / lib / Target / WebAssembly / WebAssemblyAsmPrinter.cpp

diff --git a/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp b/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp
index f7f37ee8c8946e23e1d479550f6f37b847ce3c36..079c864c7bc1c15e9a7bc5c8d238fad2829ea0af 100644 (file)
--- a/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp
+++ b/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp
@@ -34,7 +34,6 @@
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
-
 using namespace llvm;
 
 #define DEBUG_TYPE "asm-printer"
@@ -58,10 +57,6 @@ private:
   // MachineFunctionPass Implementation.
   //===------------------------------------------------------------------===//
 
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AsmPrinter::getAnalysisUsage(AU);
-  }
-
   bool runOnMachineFunction(MachineFunction &MF) override {
     MRI = &MF.getRegInfo();
     MFI = MF.getInfo<WebAssemblyFunctionInfo>();
@@ -76,7 +71,6 @@ private:
   void EmitConstantPool() override;
   void EmitFunctionBodyStart() override;
   void EmitInstruction(const MachineInstr *MI) override;
-  void EmitEndOfAsmFile(Module &M) override;
   bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
                        unsigned AsmVariant, const char *ExtraCode,
                        raw_ostream &OS) override;
@@ -116,21 +110,7 @@ std::string WebAssemblyAsmPrinter::regToString(const MachineOperand &MO) {
 }
 
 const char *WebAssemblyAsmPrinter::toString(MVT VT) const {
-  switch (VT.SimpleTy) {
-  default:
-    break;
-  case MVT::f32:
-    return "f32";
-  case MVT::f64:
-    return "f64";
-  case MVT::i32:
-    return "i32";
-  case MVT::i64:
-    return "i64";
-  }
-  DEBUG(dbgs() << "Invalid type " << EVT(VT).getEVTString() << '\n');
-  llvm_unreachable("invalid type");
-  return "<invalid>";
+  return WebAssembly::TypeToString(VT);
 }
 
 //===----------------------------------------------------------------------===//
@@ -146,11 +126,9 @@ void WebAssemblyAsmPrinter::EmitJumpTableInfo() {
   // Nothing to do; jump tables are incorporated into the instruction stream.
 }
 
-static void ComputeLegalValueVTs(const Function &F,
-                                 const TargetMachine &TM,
-                                 Type *Ty,
-                                 SmallVectorImpl<MVT> &ValueVTs) {
-  const DataLayout& DL(F.getParent()->getDataLayout());
+static void ComputeLegalValueVTs(const Function &F, const TargetMachine &TM,
+                                 Type *Ty, SmallVectorImpl<MVT> &ValueVTs) {
+  const DataLayout &DL(F.getParent()->getDataLayout());
   const WebAssemblyTargetLowering &TLI =
       *TM.getSubtarget<WebAssemblySubtarget>(F).getTargetLowering();
   SmallVector<EVT, 4> VTs;
@@ -173,7 +151,6 @@ void WebAssemblyAsmPrinter::EmitFunctionBodyStart() {
     EmitToStreamer(*OutStreamer, Param);
   }
 
-
   SmallVector<MVT, 4> ResultVTs;
   const Function &F(*MF->getFunction());
   ComputeLegalValueVTs(F, TM, F.getReturnType(), ResultVTs);
@@ -235,63 +212,6 @@ void WebAssemblyAsmPrinter::EmitInstruction(const MachineInstr *MI) {
   }
 }
 
-void WebAssemblyAsmPrinter::EmitEndOfAsmFile(Module &M) {
-  const DataLayout &DL = M.getDataLayout();
-
-  SmallString<128> Str;
-  raw_svector_ostream OS(Str);
-  for (const Function &F : M)
-    if (F.isDeclarationForLinker()) {
-      assert(F.hasName() && "imported functions must have a name");
-      if (F.isIntrinsic())
-        continue;
-      if (Str.empty())
-        OS << "\t.imports\n";
-
-      MCSymbol *Sym = OutStreamer->getContext().getOrCreateSymbol(F.getName());
-      OS << "\t.import " << *Sym << " \"\" " << *Sym;
-
-      const WebAssemblyTargetLowering &TLI =
-          *TM.getSubtarget<WebAssemblySubtarget>(F).getTargetLowering();
-
-      // If we need to legalize the return type, it'll get converted into
-      // passing a pointer.
-      bool SawParam = false;
-      SmallVector<MVT, 4> ResultVTs;
-      ComputeLegalValueVTs(F, TM, F.getReturnType(), ResultVTs);
-      if (ResultVTs.size() > 1) {
-        ResultVTs.clear();
-        OS << " (param " << toString(TLI.getPointerTy(DL));
-        SawParam = true;
-      }
-
-      for (const Argument &A : F.args()) {
-        SmallVector<MVT, 4> ParamVTs;
-        ComputeLegalValueVTs(F, TM, A.getType(), ParamVTs);
-        for (MVT VT : ParamVTs) {
-          if (!SawParam) {
-            OS << " (param";
-            SawParam = true;
-          }
-          OS << ' ' << toString(VT);
-        }
-      }
-      if (SawParam)
-        OS << ')';
-
-      for (MVT VT : ResultVTs)
-        OS << " (result " << toString(VT) << ')';
-
-      OS << '\n';
-    }
-
-  StringRef Text = OS.str();
-  if (!Text.empty())
-    OutStreamer->EmitRawText(Text.substr(0, Text.size() - 1));
-
-  AsmPrinter::EmitEndOfAsmFile(M);
-}
-
 bool WebAssemblyAsmPrinter::PrintAsmOperand(const MachineInstr *MI,
                                             unsigned OpNo, unsigned AsmVariant,
                                             const char *ExtraCode,
@@ -299,16 +219,36 @@ bool WebAssemblyAsmPrinter::PrintAsmOperand(const MachineInstr *MI,
   if (AsmVariant != 0)
     report_fatal_error("There are no defined alternate asm variants");
 
+  // First try the generic code, which knows about modifiers like 'c' and 'n'.
+  if (!AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, OS))
+    return false;
+
   if (!ExtraCode) {
     const MachineOperand &MO = MI->getOperand(OpNo);
-    if (MO.isImm())
+    switch (MO.getType()) {
+    case MachineOperand::MO_Immediate:
       OS << MO.getImm();
-    else
+      return false;
+    case MachineOperand::MO_Register:
       OS << regToString(MO);
-    return false;
+      return false;
+    case MachineOperand::MO_GlobalAddress:
+      getSymbol(MO.getGlobal())->print(OS, MAI);
+      printOffset(MO.getOffset(), OS);
+      return false;
+    case MachineOperand::MO_ExternalSymbol:
+      GetExternalSymbolSymbol(MO.getSymbolName())->print(OS, MAI);
+      printOffset(MO.getOffset(), OS);
+      return false;
+    case MachineOperand::MO_MachineBasicBlock:
+      MO.getMBB()->getSymbol()->print(OS, MAI);
+      return false;
+    default:
+      break;
+    }
   }
 
-  return AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, OS);
+  return true;
 }
 
 bool WebAssemblyAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
@@ -320,7 +260,9 @@ bool WebAssemblyAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
     report_fatal_error("There are no defined alternate asm variants");
 
   if (!ExtraCode) {
-    OS << regToString(MI->getOperand(OpNo));
+    // TODO: For now, we just hard-code 0 as the constant offset; teach
+    // SelectInlineAsmMemoryOperand how to do address mode matching.
+    OS << "0(" + regToString(MI->getOperand(OpNo)) + ')';
     return false;
   }