Subzero - WASM: Codegen fixes, better test infrastructure

src/WasmTranslator.cpp

 //===- subzero/src/WasmTranslator.cpp - WASM to Subzero Translation -------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 211 matching lines @@
   case kExprI32LtS:
   case kExprI64LtS:
   case kExprI32LtU:
   case kExprI64LtU:
   case kExprI32GeS:
   case kExprI64GeS:
   case kExprI32GtS:
   case kExprI64GtS:
   case kExprI32GtU:
   case kExprI64GtU:
+  case kExprF32Eq:
+  case kExprF64Eq:
   case kExprF32Ne:
   case kExprF64Ne:
   case kExprF32Le:
   case kExprF64Le:
+  case kExprF32Lt:
+  case kExprF64Lt:
+  case kExprF32Ge:
+  case kExprF64Ge:
+  case kExprF32Gt:
+  case kExprF64Gt:
   case kExprI32LeS:
   case kExprI64LeS:
   case kExprI32GeU:
   case kExprI64GeU:
   case kExprI32LeU:
   case kExprI64LeU:
     return true;
   default:
     return false;
   }
@@ skipping 71 matching lines @@
     assert(Count == InEdges.size());
 
     assert(Count > 0);
 
     auto *Dest = makeVariable(Vals[0].toOperand()->getType(), Control);
 
     // Multiply by 10 in case more things get added later.
 
     // TODO(eholk): find a better way besides multiplying by some arbitrary
     // constant.
-    auto *Phi = InstPhi::create(Func, Count * 10, Dest);
+    auto *Phi = InstPhi::create(Func, Count * 200, Dest);
     for (uint32_t i = 0; i < Count; ++i) {
       auto *Op = Vals[i].toOperand();
       assert(Op);
       Phi->addArgument(Op, InEdges[i]);
     }
     setDefiningInst(Dest, Phi);
     Control.toCfgNode()->appendInst(Phi);
     LOG(out << Node(Dest) << "\n");
     return OperandNode(Dest);
   }
@@ skipping 48 matching lines @@
     case kExprF32Add:
     case kExprF64Add:
       Control()->appendInst(InstArithmetic::create(Func, InstArithmetic::Fadd,
                                                    Dest, Left, Right));
       break;
     case kExprI32Sub:
     case kExprI64Sub:
       Control()->appendInst(
           InstArithmetic::create(Func, InstArithmetic::Sub, Dest, Left, Right));
       break;
+    case kExprF32Sub:
+    case kExprF64Sub:
+      Control()->appendInst(InstArithmetic::create(Func, InstArithmetic::Fsub,
+                                                   Dest, Left, Right));
+      break;
     case kExprI32Mul:
     case kExprI64Mul:
       Control()->appendInst(
           InstArithmetic::create(Func, InstArithmetic::Mul, Dest, Left, Right));
       break;
+    case kExprF32Mul:
+    case kExprF64Mul:
+      Control()->appendInst(InstArithmetic::create(Func, InstArithmetic::Fmul,
+                                                   Dest, Left, Right));
+      break;
+    case kExprI32DivS:
+    case kExprI64DivS:
+      Control()->appendInst(InstArithmetic::create(Func, InstArithmetic::Sdiv,
+                                                   Dest, Left, Right));
+      break;
     case kExprI32DivU:
     case kExprI64DivU:
       Control()->appendInst(InstArithmetic::create(Func, InstArithmetic::Udiv,
                                                    Dest, Left, Right));
       break;
+    case kExprF32Div:
+    case kExprF64Div:
+      Control()->appendInst(InstArithmetic::create(Func, InstArithmetic::Fdiv,
+                                                   Dest, Left, Right));
+      break;
     case kExprI32RemU:
     case kExprI64RemU:
       Control()->appendInst(InstArithmetic::create(Func, InstArithmetic::Urem,
                                                    Dest, Left, Right));
       break;
     case kExprI32RemS:
     case kExprI64RemS:
       Control()->appendInst(InstArithmetic::create(Func, InstArithmetic::Srem,
                                                    Dest, Left, Right));
       break;
     case kExprI32Ior:
     case kExprI64Ior:
       Control()->appendInst(
           InstArithmetic::create(Func, InstArithmetic::Or, Dest, Left, Right));
       break;
     case kExprI32Xor:
     case kExprI64Xor:
       Control()->appendInst(
           InstArithmetic::create(Func, InstArithmetic::Xor, Dest, Left, Right));
       break;
     case kExprI32Shl:
     case kExprI64Shl:
       Control()->appendInst(
           InstArithmetic::create(Func, InstArithmetic::Shl, Dest, Left, Right));
       break;
-    case kExprI32Rol: {
+    case kExprI32Rol:
+    case kExprI64Rol: {
       // TODO(eholk): add rotate as an ICE instruction to make it easier to take
       // advantage of hardware support.
 
-      // TODO(eholk): don't hardcode so many numbers.
-      auto *Masked = makeVariable(IceType_i32);
-      auto *Bottom = makeVariable(IceType_i32);
-      auto *Top = makeVariable(IceType_i32);
-      Control()->appendInst(InstArithmetic::create(
-          Func, InstArithmetic::And, Masked, Right, Ctx->getConstantInt32(31)));
+      const auto DestTy = Left.toOperand()->getType();
+      const SizeT BitCount = typeWidthInBytes(DestTy) * 8;
+
+      auto *Masked = makeVariable(DestTy);
+      auto *Bottom = makeVariable(DestTy);
+      auto *Top = makeVariable(DestTy);
+      Control()->appendInst(
+          InstArithmetic::create(Func, InstArithmetic::And, Masked, Right,
+                                 Ctx->getConstantInt(DestTy, BitCount - 1)));
       Control()->appendInst(
           InstArithmetic::create(Func, InstArithmetic::Shl, Top, Left, Masked));
-      auto *RotShift = makeVariable(IceType_i32);
+      auto *RotShift = makeVariable(DestTy);
+      Control()->appendInst(InstArithmetic::create(
+          Func, InstArithmetic::Sub, RotShift,
+          Ctx->getConstantInt(DestTy, BitCount), Masked));
+      Control()->appendInst(InstArithmetic::create(Func, InstArithmetic::Lshr,
+                                                   Bottom, Left, RotShift));
       Control()->appendInst(
-          InstArithmetic::create(Func, InstArithmetic::Sub, RotShift,
-                                 Ctx->getConstantInt32(32), Masked));
+          InstArithmetic::create(Func, InstArithmetic::Or, Dest, Top, Bottom));
+      break;
+    }
+    case kExprI32Ror:
+    case kExprI64Ror: {
+      // TODO(eholk): add rotate as an ICE instruction to make it easier to take
+      // advantage of hardware support.
+
+      const auto DestTy = Left.toOperand()->getType();
+      const SizeT BitCount = typeWidthInBytes(DestTy) * 8;
+
+      auto *Masked = makeVariable(DestTy);
+      auto *Bottom = makeVariable(DestTy);
+      auto *Top = makeVariable(DestTy);
+      Control()->appendInst(
+          InstArithmetic::create(Func, InstArithmetic::And, Masked, Right,
+                                 Ctx->getConstantInt(DestTy, BitCount - 1)));
       Control()->appendInst(InstArithmetic::create(Func, InstArithmetic::Lshr,
-                                                   Bottom, Left, Masked));
+                                                   Top, Left, Masked));
+      auto *RotShift = makeVariable(DestTy);
+      Control()->appendInst(InstArithmetic::create(
+          Func, InstArithmetic::Sub, RotShift,
+          Ctx->getConstantInt(DestTy, BitCount), Masked));
+      Control()->appendInst(InstArithmetic::create(Func, InstArithmetic::Shl,
+                                                   Bottom, Left, RotShift));
       Control()->appendInst(
           InstArithmetic::create(Func, InstArithmetic::Or, Dest, Top, Bottom));
       break;
     }
     case kExprI32ShrU:
     case kExprI64ShrU:
+      Control()->appendInst(InstArithmetic::create(Func, InstArithmetic::Lshr,
+                                                   Dest, Left, Right));
+      break;
     case kExprI32ShrS:
     case kExprI64ShrS:
       Control()->appendInst(InstArithmetic::create(Func, InstArithmetic::Ashr,
                                                    Dest, Left, Right));
       break;
     case kExprI32And:
     case kExprI64And:
       Control()->appendInst(
           InstArithmetic::create(Func, InstArithmetic::And, Dest, Left, Right));
       break;
@@ skipping 60 matching lines @@
           InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
       break;
     }
     case kExprI32GeS:
     case kExprI64GeS: {
       auto *TmpDest = makeVariable(IceType_i1);
       Control()->appendInst(
           InstIcmp::create(Func, InstIcmp::Sge, TmpDest, Left, Right));
       Control()->appendInst(
           InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
+      break;
     }
     case kExprI32GtS:
     case kExprI64GtS: {
       auto *TmpDest = makeVariable(IceType_i1);
       Control()->appendInst(
           InstIcmp::create(Func, InstIcmp::Sgt, TmpDest, Left, Right));
       Control()->appendInst(
           InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
       break;
     }
     case kExprI32GtU:
     case kExprI64GtU: {
       auto *TmpDest = makeVariable(IceType_i1);
       Control()->appendInst(
           InstIcmp::create(Func, InstIcmp::Ugt, TmpDest, Left, Right));
       Control()->appendInst(
           InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
       break;
     }
+    case kExprF32Eq:
+    case kExprF64Eq: {
+      auto *TmpDest = makeVariable(IceType_i1);
+      Control()->appendInst(
+          InstFcmp::create(Func, InstFcmp::Ueq, TmpDest, Left, Right));
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
+      break;
+    }
     case kExprF32Ne:
     case kExprF64Ne: {
       auto *TmpDest = makeVariable(IceType_i1);
       Control()->appendInst(
           InstFcmp::create(Func, InstFcmp::Une, TmpDest, Left, Right));
       Control()->appendInst(
           InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
       break;
     }
     case kExprF32Le:
     case kExprF64Le: {
       auto *TmpDest = makeVariable(IceType_i1);
       Control()->appendInst(
           InstFcmp::create(Func, InstFcmp::Ule, TmpDest, Left, Right));
       Control()->appendInst(
           InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
       break;
     }
+    case kExprF32Lt:
+    case kExprF64Lt: {
+      auto *TmpDest = makeVariable(IceType_i1);
+      Control()->appendInst(
+          InstFcmp::create(Func, InstFcmp::Ult, TmpDest, Left, Right));
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
+      break;
+    }
+    case kExprF32Ge:
+    case kExprF64Ge: {
+      auto *TmpDest = makeVariable(IceType_i1);
+      Control()->appendInst(
+          InstFcmp::create(Func, InstFcmp::Uge, TmpDest, Left, Right));
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
+      break;
+    }
+    case kExprF32Gt:
+    case kExprF64Gt: {
+      auto *TmpDest = makeVariable(IceType_i1);
+      Control()->appendInst(
+          InstFcmp::create(Func, InstFcmp::Ugt, TmpDest, Left, Right));
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
+      break;
+    }
     default:
       LOG(out << "Unknown binop: " << WasmOpcodes::OpcodeName(Opcode) << "\n");
       llvm::report_fatal_error("Uncovered or invalid binop.");
       return OperandNode(nullptr);
     }
     LOG(out << Dest << "\n");
     return OperandNode(Dest);
   }
   Node Unop(wasm::WasmOpcode Opcode, Node Input) {
     LOG(out << "Unop(" << WasmOpcodes::OpcodeName(Opcode) << ", " << Input
             << ") = ");
     Ice::Variable *Dest = nullptr;
     switch (Opcode) {
     case kExprI32Eqz: {
       Dest = makeVariable(IceType_i32);
       auto *Tmp = makeVariable(IceType_i1);
       Control()->appendInst(InstIcmp::create(Func, InstIcmp::Eq, Tmp, Input,
                                              Ctx->getConstantInt32(0)));
       Control()->appendInst(InstCast::create(Func, InstCast::Zext, Dest, Tmp));
       break;
     }
     case kExprI64Eqz: {
       Dest = makeVariable(IceType_i32);
       auto *Tmp = makeVariable(IceType_i1);
       Control()->appendInst(InstIcmp::create(Func, InstIcmp::Eq, Tmp, Input,
                                              Ctx->getConstantInt64(0)));
       Control()->appendInst(InstCast::create(Func, InstCast::Zext, Dest, Tmp));
       break;
     }
+    case kExprI32Ctz: {
+      Dest = makeVariable(IceType_i32);
+      const auto FnName = Ctx->getGlobalString("llvm.cttz.i32");
+      bool BadInstrinsic = false;
+      const auto *Info = Ctx->getIntrinsicsInfo().find(FnName, BadInstrinsic);
+      assert(!BadInstrinsic);
+      assert(Info);
+
+      auto *Call = InstIntrinsicCall::create(
+          Func, 1, Dest, Ctx->getConstantExternSym(FnName), Info->Info);
+      Call->addArg(Input);
+      Control()->appendInst(Call);
+      break;
+    }
     case kExprF32Neg: {
       Dest = makeVariable(IceType_f32);
       Control()->appendInst(InstArithmetic::create(
           Func, InstArithmetic::Fsub, Dest, Ctx->getConstantFloat(0), Input));
       break;
     }
     case kExprF64Neg: {
       Dest = makeVariable(IceType_f64);
       Control()->appendInst(InstArithmetic::create(
           Func, InstArithmetic::Fsub, Dest, Ctx->getConstantDouble(0), Input));
       break;
     }
+    case kExprF32Abs: {
+      Dest = makeVariable(IceType_f32);
+      const auto FnName = Ctx->getGlobalString("llvm.fabs.f32");
+      bool BadInstrinsic = false;
+      const auto *Info = Ctx->getIntrinsicsInfo().find(FnName, BadInstrinsic);
+      assert(!BadInstrinsic);
+      assert(Info);
+
+      auto *Call = InstIntrinsicCall::create(
+          Func, 1, Dest, Ctx->getConstantExternSym(FnName), Info->Info);
+      Call->addArg(Input);
+      Control()->appendInst(Call);
+      break;
+    }
+    case kExprF64Abs: {
+      Dest = makeVariable(IceType_f64);
+      const auto FnName = Ctx->getGlobalString("llvm.fabs.f64");
+      bool BadInstrinsic = false;
+      const auto *Info = Ctx->getIntrinsicsInfo().find(FnName, BadInstrinsic);
+      assert(!BadInstrinsic);
+      assert(Info);
+
+      auto *Call = InstIntrinsicCall::create(
+          Func, 1, Dest, Ctx->getConstantExternSym(FnName), Info->Info);
+      Call->addArg(Input);
+      Control()->appendInst(Call);
+      break;
+    }
+    case kExprF32Floor: {
+      Dest = makeVariable(IceType_f64);
+      const auto FnName = Ctx->getGlobalString("_ZN3env5floorEf");
+      constexpr bool HasTailCall = false;
+
+      auto *Call = InstCall::create(
+          Func, 1, Dest, Ctx->getConstantExternSym(FnName), HasTailCall);
+      Call->addArg(Input);
+      Control()->appendInst(Call);
+      break;
+    }
+    case kExprF64Floor: {
+      Dest = makeVariable(IceType_f64);
+      const auto FnName = Ctx->getGlobalString("_ZN3env5floorEd");
+      constexpr bool HasTailCall = false;
+
+      auto *Call = InstCall::create(
+          Func, 1, Dest, Ctx->getConstantExternSym(FnName), HasTailCall);
+      Call->addArg(Input);
+      Control()->appendInst(Call);
+      break;
+    }
     case kExprI64UConvertI32:
       Dest = makeVariable(IceType_i64);
       Control()->appendInst(
           InstCast::create(Func, InstCast::Zext, Dest, Input));
       break;
     case kExprI64SConvertI32:
       Dest = makeVariable(IceType_i64);
       Control()->appendInst(
           InstCast::create(Func, InstCast::Sext, Dest, Input));
       break;
+    case kExprI32SConvertF32:
+      Dest = makeVariable(IceType_i32);
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Fptosi, Dest, Input));
+      break;
+    case kExprI32UConvertF32:
+      Dest = makeVariable(IceType_i32);
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Fptoui, Dest, Input));
+      break;
+    case kExprI32SConvertF64:
+      Dest = makeVariable(IceType_i32);
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Fptosi, Dest, Input));
+      break;
+    case kExprI32UConvertF64:
+      Dest = makeVariable(IceType_i32);
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Fptoui, Dest, Input));
+      break;
+    case kExprI32ReinterpretF32:
+      Dest = makeVariable(IceType_i32);
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Bitcast, Dest, Input));
+      break;
+    case kExprI64ReinterpretF64:
+      Dest = makeVariable(IceType_i64);
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Bitcast, Dest, Input));
+      break;
+    case kExprF64ReinterpretI64:
+      Dest = makeVariable(IceType_f64);
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Bitcast, Dest, Input));
+      break;
     case kExprI32ConvertI64:
       Dest = makeVariable(IceType_i32);
       Control()->appendInst(
           InstCast::create(Func, InstCast::Trunc, Dest, Input));
       break;
     case kExprF64SConvertI32:
       Dest = makeVariable(IceType_f64);
       Control()->appendInst(
           InstCast::create(Func, InstCast::Sitofp, Dest, Input));
       break;
+    case kExprF64UConvertI32:
+      Dest = makeVariable(IceType_f64);
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Uitofp, Dest, Input));
+      break;
+    case kExprF64ConvertF32:
+      Dest = makeVariable(IceType_f64);
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Fpext, Dest, Input));
+      break;
+    case kExprF32SConvertI32:
+      Dest = makeVariable(IceType_f32);
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Sitofp, Dest, Input));
+      break;
+    case kExprF32UConvertI32:
+      Dest = makeVariable(IceType_f32);
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Uitofp, Dest, Input));
+      break;
+    case kExprF32ReinterpretI32:
+      Dest = makeVariable(IceType_f32);
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Bitcast, Dest, Input));
+      break;
+    case kExprF32ConvertF64:
+      Dest = makeVariable(IceType_f32);
+      Control()->appendInst(
+          InstCast::create(Func, InstCast::Fptrunc, Dest, Input));
+      break;
     default:
       LOG(out << "Unknown unop: " << WasmOpcodes::OpcodeName(Opcode) << "\n");
       llvm::report_fatal_error("Uncovered or invalid unop.");
       return OperandNode(nullptr);
     }
     LOG(out << Dest << "\n");
     return OperandNode(Dest);
   }
   uint32_t InputCount(CfgNode *Node) const { return Node->getInEdges().size(); }
   bool IsPhiWithMerge(Node Phi, Node Merge) const {
@@ skipping 303 matching lines @@
 
       RealAddr = RealAddrV;
     } else {
       RealAddr = MemBase;
     }
     return RealAddr;
   }
 
   Node LoadMem(wasm::LocalType Type, MachineType MemType, Node Index,
                uint32_t Offset) {
-    LOG(out << "LoadMem(" << Index << "[" << Offset << "]) = ");
+    LOG(out << "LoadMem." << toIceType(MemType) << "(" << Index << "[" << Offset
+            << "]) = ");
 
     auto *RealAddr = sanitizeAddress(Index, Offset);
 
     auto *LoadResult = makeVariable(toIceType(MemType));
     Control()->appendInst(InstLoad::create(Func, LoadResult, RealAddr));
 
     // and cast, if needed
     Ice::Variable *Result = nullptr;
     if (toIceType(Type) != toIceType(MemType)) {
       auto DestType = toIceType(Type);
@@ skipping 14 matching lines @@
         llvm::report_fatal_error("Unsupported type for memory load");
       }
     } else {
       Result = LoadResult;
     }
 
     LOG(out << Result << "\n");
     return OperandNode(Result);
   }
   void StoreMem(MachineType Type, Node Index, uint32_t Offset, Node Val) {
-    LOG(out << "StoreMem(" << Index << "[" << Offset << "] = " << Val << ")"
+    LOG(out << "StoreMem." << toIceType(Type) << "(" << Index << "[" << Offset
+            << "] = " << Val << ")"
             << "\n");
 
     auto *RealAddr = sanitizeAddress(Index, Offset);
 
     // cast the value to the right type, if needed
     Operand *StoreVal = nullptr;
     if (toIceType(Type) != Val.toOperand()->getType()) {
       auto *LocalStoreVal = makeVariable(toIceType(Type));
       Control()->appendInst(
           InstCast::create(Func, InstCast::Trunc, LocalStoreVal, Val));
@@ skipping 92 matching lines @@
 
   // We don't always know where the incoming branches are in phi nodes, so this
   // function finds them.
   Func->fixPhiNodes();
 
   Func->computeInOutEdges();
 
   return Func;
 }
 
+// TODO(eholk): compute the correct buffer size. This uses 256k by default,
+// which has been big enough for testing but is not a general solution.
+constexpr SizeT BUFFER_SIZE = 256 << 10;
+
 WasmTranslator::WasmTranslator(GlobalContext *Ctx)
-    : Translator(Ctx), Buffer(new uint8_t[24 << 10]), BufferSize(24 << 10) {
-  // TODO(eholk): compute the correct buffer size. This uses 24k by default,
-  // which has been big enough for testing but is not a general solution.
-}
+    : Translator(Ctx), Buffer(new uint8_t[BUFFER_SIZE]),
+      BufferSize(BUFFER_SIZE) {}
 
 void WasmTranslator::translate(
     const std::string &IRFilename,
     std::unique_ptr<llvm::DataStreamer> InputStream) {
   LOG(out << "Initializing v8/wasm stuff..."
           << "\n");
   Zone Zone;
   ZoneScope _(&Zone);
 
   SizeT BytesRead = InputStream->GetBytes(Buffer.get(), BufferSize);
   LOG(out << "Read " << BytesRead << " bytes"
           << "\n");
+  assert(BytesRead < BufferSize);
 
   LOG(out << "Decoding module " << IRFilename << "\n");
 
   constexpr v8::internal::Isolate *NoIsolate = nullptr;
   auto Result = DecodeWasmModule(NoIsolate, &Zone, Buffer.get(),
                                  Buffer.get() + BytesRead, false, kWasmOrigin);
 
   auto Module = Result.val;
 
   LOG(out << "Module info:"
@@ skipping 134 matching lines @@
     Func->setFunctionName(Ctx->getGlobalString(FnName));
 
     Ctx->optQueueBlockingPush(makeUnique<CfgOptWorkItem>(std::move(Func)));
     LOG(out << "done.\n");
   }
 
   return;
 }
 
 #endif // ALLOW_WASM