[WebAssembly] Switch to a more traditional assembly syntax
[oota-llvm.git] / lib / Target / WebAssembly / WebAssemblyAsmPrinter.cpp
index aa7734118a60cfd3d6fa7781841cb9597345336b..f62cec9f59437b12ea1162a08cdfa8e754e17f12 100644 (file)
@@ -22,6 +22,7 @@
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
 
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineInstr.h"
@@ -41,6 +42,7 @@ namespace {
 
 class WebAssemblyAsmPrinter final : public AsmPrinter {
   const WebAssemblyInstrInfo *TII;
+  unsigned NumArgs;
 
 public:
   WebAssemblyAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer)
@@ -60,7 +62,9 @@ private:
   }
 
   bool runOnMachineFunction(MachineFunction &MF) override {
-    TII = MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
+    const auto &Subtarget = MF.getSubtarget<WebAssemblySubtarget>();
+    TII = Subtarget.getInstrInfo();
+    NumArgs = MF.getInfo<WebAssemblyFunctionInfo>()->getNumArguments();
     return AsmPrinter::runOnMachineFunction(MF);
   }
 
@@ -68,23 +72,29 @@ private:
   // AsmPrinter Implementation.
   //===------------------------------------------------------------------===//
 
+  void EmitJumpTableInfo() override;
   void EmitConstantPool() override;
-  void EmitFunctionEntryLabel() override;
   void EmitFunctionBodyStart() override;
-  void EmitFunctionBodyEnd() override;
 
   void EmitInstruction(const MachineInstr *MI) override;
+
+  static std::string toString(const APFloat &APF);
+  const char *toString(Type *Ty) const;
+  std::string regToString(unsigned RegNo);
+  std::string argToString(unsigned ArgNo);
 };
 
 } // end anonymous namespace
 
+//===----------------------------------------------------------------------===//
+// Helpers.
 //===----------------------------------------------------------------------===//
 
 // Untyped, lower-case version of the opcode's name matching the names
 // WebAssembly opcodes are expected to have. The tablegen names are uppercase
 // and suffixed with their type (after an underscore).
-static SmallString<32> Name(const WebAssemblyInstrInfo *TII,
-                            const MachineInstr *MI) {
+static SmallString<32> OpcodeName(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;
@@ -93,16 +103,69 @@ static SmallString<32> Name(const WebAssemblyInstrInfo *TII,
 
 static std::string toSymbol(StringRef S) { return ("$" + S).str(); }
 
-static const char *toType(const Type *Ty) {
+std::string WebAssemblyAsmPrinter::toString(const APFloat &FP) {
+  static const size_t BufBytes = 128;
+  char buf[BufBytes];
+  if (FP.isNaN())
+    assert((FP.bitwiseIsEqual(APFloat::getQNaN(FP.getSemantics())) ||
+            FP.bitwiseIsEqual(
+                APFloat::getQNaN(FP.getSemantics(), /*Negative=*/true))) &&
+           "convertToHexString handles neither SNaN nor NaN payloads");
+  // Use C99's hexadecimal floating-point representation.
+  auto Written = FP.convertToHexString(
+      buf, /*hexDigits=*/0, /*upperCase=*/false, APFloat::rmNearestTiesToEven);
+  (void)Written;
+  assert(Written != 0);
+  assert(Written < BufBytes);
+  return buf;
+}
+
+std::string WebAssemblyAsmPrinter::regToString(unsigned RegNo) {
+  if (TargetRegisterInfo::isPhysicalRegister(RegNo))
+    return WebAssemblyInstPrinter::getRegisterName(RegNo);
+
+  // WebAssembly arguments and local variables are in the same index space, and
+  // there are no explicit varargs, so we just add the number of arguments to
+  // the virtual register number to get the local variable number.
+  return '@' + utostr(TargetRegisterInfo::virtReg2Index(RegNo) + NumArgs);
+}
+
+std::string WebAssemblyAsmPrinter::argToString(unsigned ArgNo) {
+  // Same as above, but we don't need to add NumArgs here.
+  return '@' + utostr(ArgNo);
+}
+
+const char *WebAssemblyAsmPrinter::toString(Type *Ty) const {
   switch (Ty->getTypeID()) {
-  default: break;
-  case Type::FloatTyID:  return "f32";
-  case Type::DoubleTyID: return "f64";
+  default:
+    break;
+  // Treat all pointers as the underlying integer into linear memory.
+  case Type::PointerTyID:
+    switch (getPointerSize()) {
+    case 4:
+      return "i32";
+    case 8:
+      return "i64";
+    default:
+      llvm_unreachable("unsupported pointer size");
+    }
+    break;
+  case Type::FloatTyID:
+    return "f32";
+  case Type::DoubleTyID:
+    return "f64";
   case Type::IntegerTyID:
     switch (Ty->getIntegerBitWidth()) {
-    case 32: return "i32";
-    case 64: return "i64";
-    default: break;
+    case 8:
+      return "i8";
+    case 16:
+      return "i16";
+    case 32:
+      return "i32";
+    case 64:
+      return "i64";
+    default:
+      break;
     }
   }
   DEBUG(dbgs() << "Invalid type "; Ty->print(dbgs()); dbgs() << '\n');
@@ -110,48 +173,43 @@ static const char *toType(const Type *Ty) {
   return "<invalid>";
 }
 
+//===----------------------------------------------------------------------===//
+// WebAssemblyAsmPrinter Implementation.
+//===----------------------------------------------------------------------===//
+
 void WebAssemblyAsmPrinter::EmitConstantPool() {
   assert(MF->getConstantPool()->getConstants().empty() &&
          "WebAssembly disables constant pools");
 }
 
-void WebAssemblyAsmPrinter::EmitFunctionEntryLabel() {
-  SmallString<128> Str;
-  raw_svector_ostream OS(Str);
-
-  CurrentFnSym->redefineIfPossible();
-
-  // The function label could have already been emitted if two symbols end up
-  // conflicting due to asm renaming.  Detect this and emit an error.
-  if (CurrentFnSym->isVariable())
-    report_fatal_error("'" + Twine(CurrentFnSym->getName()) +
-                       "' is a protected alias");
-  if (CurrentFnSym->isDefined())
-    report_fatal_error("'" + Twine(CurrentFnSym->getName()) +
-                       "' label emitted multiple times to assembly file");
-
-  OS << "(func " << toSymbol(CurrentFnSym->getName());
-  OutStreamer->EmitRawText(OS.str());
+void WebAssemblyAsmPrinter::EmitJumpTableInfo() {
+  // Nothing to do; jump tables are incorporated into the instruction stream.
 }
 
 void WebAssemblyAsmPrinter::EmitFunctionBodyStart() {
-  SmallString<128> Str;
-  raw_svector_ostream OS(Str);
   const Function *F = MF->getFunction();
-  for (const Argument &A : F->args())
-    OS << " (param " << toType(A.getType()) << ')';
-  const Type *Rt = F->getReturnType();
-  if (!Rt->isVoidTy())
-    OS << " (result " << toType(Rt) << ')';
-  OS << '\n';
-  OutStreamer->EmitRawText(OS.str());
-}
+  Type *Rt = F->getReturnType();
+
+  if (!Rt->isVoidTy() || !F->arg_empty()) {
+    SmallString<128> Str;
+    raw_svector_ostream OS(Str);
+    bool First = true;
+    for (const Argument &A : F->args()) {
+      OS << (First ? "" : "\n") << "\t"
+                                   ".param "
+         << toString(A.getType());
+      First = false;
+    }
+    if (!Rt->isVoidTy()) {
+      OS << (First ? "" : "\n") << "\t"
+                                   ".result "
+         << toString(Rt);
+      First = false;
+    }
+    OutStreamer->EmitRawText(OS.str());
+  }
 
-void WebAssemblyAsmPrinter::EmitFunctionBodyEnd() {
-  SmallString<128> Str;
-  raw_svector_ostream OS(Str);
-  OS << ") ;; end func " << toSymbol(CurrentFnSym->getName()) << '\n';
-  OutStreamer->EmitRawText(OS.str());
+  AsmPrinter::EmitFunctionBodyStart();
 }
 
 void WebAssemblyAsmPrinter::EmitInstruction(const MachineInstr *MI) {
@@ -165,56 +223,76 @@ void WebAssemblyAsmPrinter::EmitInstruction(const MachineInstr *MI) {
 
   OS << '\t';
 
-  if (NumDefs != 0) {
-    const MachineOperand &MO = MI->getOperand(0);
-    unsigned Reg = MO.getReg();
-    OS << "(setlocal @" << TargetRegisterInfo::virtReg2Index(Reg) << ' ';
-  }
-
-  OS << '(' << Name(TII, MI);
-  for (const MachineOperand &MO : MI->uses())
-    switch (MO.getType()) {
-    default:
-      llvm_unreachable("unexpected machine operand type");
-    case MachineOperand::MO_Register: {
-      if (MO.isImplicit())
+  switch (MI->getOpcode()) {
+  case TargetOpcode::COPY:
+    OS << regToString(MI->getOperand(1).getReg());
+    break;
+  case WebAssembly::GLOBAL:
+    // TODO: wasm64
+    OS << "i32.const " << toSymbol(MI->getOperand(1).getGlobal()->getName());
+    break;
+  case WebAssembly::ARGUMENT_I32:
+  case WebAssembly::ARGUMENT_I64:
+  case WebAssembly::ARGUMENT_F32:
+  case WebAssembly::ARGUMENT_F64:
+    OS << argToString(MI->getOperand(1).getImm());
+    break;
+  case WebAssembly::Immediate_I32:
+    OS << "i32.const " << MI->getOperand(1).getImm();
+    break;
+  case WebAssembly::Immediate_I64:
+    OS << "i64.const " << MI->getOperand(1).getImm();
+    break;
+  case WebAssembly::Immediate_F32:
+    OS << "f32.const " << toString(MI->getOperand(1).getFPImm()->getValueAPF());
+    break;
+  case WebAssembly::Immediate_F64:
+    OS << "f64.const " << toString(MI->getOperand(1).getFPImm()->getValueAPF());
+    break;
+  default: {
+    OS << OpcodeName(TII, MI);
+    bool NeedComma = false;
+    for (const MachineOperand &MO : MI->uses()) {
+      if (MO.isReg() && MO.isImplicit())
         continue;
-      unsigned Reg = MO.getReg();
-      OS << " @" << TargetRegisterInfo::virtReg2Index(Reg);
-    } break;
-    case MachineOperand::MO_Immediate: {
-      OS << ' ' << MO.getImm();
-    } break;
-    case MachineOperand::MO_FPImmediate: {
-      static const size_t BufBytes = 128;
-      char buf[BufBytes];
-      APFloat FP = MO.getFPImm()->getValueAPF();
-      if (FP.isNaN())
-        assert((FP.bitwiseIsEqual(APFloat::getQNaN(FP.getSemantics())) ||
-                FP.bitwiseIsEqual(
-                    APFloat::getQNaN(FP.getSemantics(), /*Negative=*/true))) &&
-               "convertToHexString handles neither SNaN nor NaN payloads");
-      // Use C99's hexadecimal floating-point representation.
-      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;
+      if (NeedComma)
+        OS << ',';
+      NeedComma = true;
+      OS << ' ';
+      switch (MO.getType()) {
+      default:
+        llvm_unreachable("unexpected machine operand type");
+      case MachineOperand::MO_Register:
+        OS << regToString(MO.getReg());
+        break;
+      case MachineOperand::MO_Immediate:
+        OS << MO.getImm();
+        break;
+      case MachineOperand::MO_FPImmediate:
+        OS << toString(MO.getFPImm()->getValueAPF());
+        break;
+      case MachineOperand::MO_GlobalAddress:
+        OS << toSymbol(MO.getGlobal()->getName());
+        break;
+      case MachineOperand::MO_MachineBasicBlock:
+        OS << toSymbol(MO.getMBB()->getSymbol()->getName());
+        break;
+      }
     }
-  OS << ')';
-
-  if (NumDefs != 0)
-    OS << ')';
-
-  OS << '\n';
+    break;
+  }
+  }
 
   OutStreamer->EmitRawText(OS.str());
+
+  if (NumDefs != 0) {
+    SmallString<128> Str;
+    raw_svector_ostream OS(Str);
+    OS << "\t" "set_local "
+       << regToString(MI->getOperand(0).getReg()) << ", "
+          "pop";
+    OutStreamer->EmitRawText(OS.str());
+  }
 }
 
 // Force static initialization.