Subzero, Wasm: Dynamically reallocate read buffer. Runtime improvements.

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 662 matching lines @@
       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) {
+    // TODO (eholk): merge these next two cases using getConstantInteger
     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);
@@ skipping 72 matching lines @@
       Dest = makeVariable(IceType_f64);
       const auto FnName = Ctx->getGlobalString("env$$floor_d");
       constexpr bool HasTailCall = false;
 
       auto *Call = InstCall::create(
           Func, 1, Dest, Ctx->getConstantExternSym(FnName), HasTailCall);
       Call->addArg(Input);
       Control()->appendInst(Call);
       break;
     }
+    case kExprF32Sqrt: {
+      Dest = makeVariable(IceType_f32);
+      const auto FnName = Ctx->getGlobalString("llvm.sqrt.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 kExprF64Sqrt: {
+      Dest = makeVariable(IceType_f64);
+      const auto FnName = Ctx->getGlobalString("llvm.sqrt.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 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;
@@ skipping 273 matching lines @@
     LOG(out << "Call Result = " << Node(Dest) << "\n");
     return OperandNode(Dest);
   }
   Node CallIndirect(uint32_t SigIndex, Node *Args) {
     LOG(out << "CallIndirect(" << SigIndex << ")\n");
     // TODO(eholk): Compile to something better than a switch.
     const auto *Module = this->Module->module;
     assert(Module);
     const auto &IndirectTable = Module->function_table;
 
-    auto *Abort = getAbortTarget();
+    auto *Abort = getIndirectFailTarget();
 
     assert(Args[0].toOperand());
 
     auto *Switch = InstSwitch::create(Func, IndirectTable.size(),
                                       Args[0].toOperand(), Abort);
     assert(Abort);
 
     const bool HasReturn = Module->signatures[SigIndex]->return_count() != 0;
     const Ice::Type DestTy =
         HasReturn ? toIceType(Module->signatures[SigIndex]->GetReturn())
@@ skipping 87 matching lines @@
     // Do the bounds check.
     //
     // TODO (eholk): Add a command line argument to control whether bounds
     // checks are inserted, and maybe add a way to duplicate bounds checks to
     // get a better sense of the overhead.
     if (!llvm::dyn_cast<ConstantInteger32>(Base)) {
       // TODO (eholk): creating a new basic block on every memory access is
       // terrible (see https://goo.gl/Zj7DTr). Try adding a new instruction that
       // encapsulates this "abort if false" pattern.
       auto *CheckPassed = Func->makeNode();
-      auto *CheckFailed = getAbortTarget();
+      auto *CheckFailed = getBoundsFailTarget();
 
       auto *Check = makeVariable(IceType_i1);
       Control()->appendInst(InstIcmp::create(Func, InstIcmp::Ult, Check, Base,
                                              Ctx->getConstantInt32(MemSize)));
       Control()->appendInst(
           InstBr::create(Func, Check, CheckPassed, CheckFailed));
 
       *ControlPtr = OperandNode(CheckPassed);
     }
 
@@ skipping 87 matching lines @@
   void set_effect_ptr(Node *Effect) { this->EffectPtr = Effect; }
 
 private:
   wasm::ModuleEnv *Module;
   Node *ControlPtr;
   Node *EffectPtr;
 
   class Cfg *Func;
   GlobalContext *Ctx;
 
-  CfgNode *AbortTarget = nullptr;
+  CfgNode *BoundsFailTarget = nullptr;
+  CfgNode *IndirectFailTarget = nullptr;
 
   SizeT NextArg = 0;
 
   CfgUnorderedMap<Operand *, InstPhi *> PhiMap;
   CfgUnorderedMap<Operand *, CfgNode *> DefNodeMap;
 
   InstPhi *getDefiningInst(Operand *Op) const {
     const auto &Iter = PhiMap.find(Op);
     if (Iter == PhiMap.end()) {
       return nullptr;
@@ skipping 17 matching lines @@
   }
 
   CfgNode *getDefNode(Operand *Op) const {
     const auto &Iter = DefNodeMap.find(Op);
     if (Iter == DefNodeMap.end()) {
       return nullptr;
     }
     return Iter->second;
   }
 
-  CfgNode *getAbortTarget() {
-    if (!AbortTarget) {
+  CfgNode *getBoundsFailTarget() {
+    if (!BoundsFailTarget) {
       // TODO (eholk): Move this node to the end of the CFG, or even better,
       // have only one abort block for the whole module.
-      AbortTarget = Func->makeNode();
-      // TODO (eholk): This should probably actually call abort instead.
-      AbortTarget->appendInst(InstUnreachable::create(Func));
+      BoundsFailTarget = Func->makeNode();
+      BoundsFailTarget->appendInst(InstCall::create(
+          Func, 0, nullptr,
+          Ctx->getConstantExternSym(Ctx->getGlobalString("__Sz_bounds_fail")),
+          false));
+      BoundsFailTarget->appendInst(InstUnreachable::create(Func));
     }
 
-    return AbortTarget;
+    return BoundsFailTarget;
+  }
+  CfgNode *getIndirectFailTarget() {
+    if (!IndirectFailTarget) {
+      // TODO (eholk): Move this node to the end of the CFG, or even better,
+      // have only one abort block for the whole module.
+      IndirectFailTarget = Func->makeNode();
+      IndirectFailTarget->appendInst(InstCall::create(
+          Func, 0, nullptr,
+          Ctx->getConstantExternSym(Ctx->getGlobalString("__Sz_indirect_fail")),
+          false));
+      IndirectFailTarget->appendInst(InstUnreachable::create(Func));
+    }
+
+    return IndirectFailTarget;
   }
 
   template <typename F = std::function<void(Ostream &)>> void log(F Fn) const {
     if (BuildDefs::dump() && (getFlags().getVerbose() & IceV_Wasm)) {
       Fn(Ctx->getStrDump());
       Ctx->getStrDump().flush();
     }
   }
 };
 
@@ skipping 15 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 BufferSize = 256 << 10;
+constexpr SizeT InitialBufferSize = 16 << 10; // 16KB
 
 WasmTranslator::WasmTranslator(GlobalContext *Ctx)
-    : Translator(Ctx), Buffer(new uint8_t[ ::BufferSize]),
-      BufferSize(::BufferSize) {}
+    : Translator(Ctx), Buffer(InitialBufferSize) {}
 
 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);
+  SizeT BytesRead = 0;
+  while (true) {
+    BytesRead +=
+        InputStream->GetBytes(&Buffer[BytesRead], Buffer.size() - BytesRead);
+    LOG(out << "Read " << BytesRead << " bytes"
+            << "\n");
+    if (BytesRead < Buffer.size())
+      break;
+    Buffer.resize(Buffer.size() * 2);
+  }
 
   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 Result = DecodeWasmModule(NoIsolate, &Zone, Buffer.data(),
+                                 Buffer.data() + BytesRead, false, kWasmOrigin);
 
   auto Module = Result.val;
 
   LOG(out << "Module info:"
           << "\n");
   LOG(out << "  min_mem_pages:           " << Module->min_mem_pages << "\n");
   LOG(out << "  max_mem_pages:           " << Module->max_mem_pages << "\n");
   LOG(out << "  number of globals:       " << Module->globals.size() << "\n");
   LOG(out << "  number of signatures:    " << Module->signatures.size()
           << "\n");
@@ skipping 130 matching lines @@
     lowerGlobals(std::move(Globals));
   }
 
   // Translate each function.
   for (const auto Fn : Module->functions) {
     const auto FnName = getFunctionName(Module, Fn.func_index);
 
     LOG(out << "  " << Fn.func_index << ": " << FnName << "...");
 
     Body.sig = Fn.sig;
-    Body.base = Buffer.get();
-    Body.start = Buffer.get() + Fn.code_start_offset;
-    Body.end = Buffer.get() + Fn.code_end_offset;
+    Body.base = Buffer.data();
+    Body.start = Buffer.data() + Fn.code_start_offset;
+    Body.end = Buffer.data() + Fn.code_end_offset;
 
     auto Func = translateFunction(&Zone, Body);
     Func->setFunctionName(Ctx->getGlobalString(FnName));
 
     Ctx->optQueueBlockingPush(makeUnique<CfgOptWorkItem>(std::move(Func)));
     LOG(out << "done.\n");
   }
 
   return;
 }
 
 #endif // ALLOW_WASM