Subzero, Wasm: Link and run torture tests; bug fixes.

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 40 matching lines @@
 using namespace Ice;
 using namespace v8;
 using namespace v8::internal;
 using namespace v8::internal::wasm;
 using v8::internal::wasm::DecodeWasmModule;
 
 #undef LOG
 #define LOG(Expr) log([&](Ostream & out) { Expr; })
 
 namespace {
+// 64KB
+const uint32_t WASM_PAGE_SIZE = 64 << 10;
 
 std::string toStdString(WasmName Name) {
   return std::string(Name.name, Name.length);
 }
 
 Ice::Type toIceType(wasm::LocalType Type) {
   switch (Type) {
   case MachineRepresentation::kNone:
     llvm::report_fatal_error("kNone type not supported");
   case MachineRepresentation::kBit:
@@ skipping 388 matching lines @@
     case kExprI64And:
       Control()->appendInst(
           InstArithmetic::create(Func, InstArithmetic::And, Dest, Left, Right));
       break;
     case kExprI32Ne:
     case kExprI64Ne: {
       auto *TmpDest = makeVariable(IceType_i1);
       Control()->appendInst(
           InstIcmp::create(Func, InstIcmp::Ne, TmpDest, Left, Right));
       Control()->appendInst(
-          InstCast::create(Func, InstCast::Sext, Dest, TmpDest));
+          InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
       break;
     }
     case kExprI32Eq:
     case kExprI64Eq: {
       auto *TmpDest = makeVariable(IceType_i1);
       Control()->appendInst(
           InstIcmp::create(Func, InstIcmp::Eq, TmpDest, Left, Right));
       Control()->appendInst(
-          InstCast::create(Func, InstCast::Sext, Dest, TmpDest));
+          InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
       break;
     }
     case kExprI32LtS:
     case kExprI64LtS: {
       auto *TmpDest = makeVariable(IceType_i1);
       Control()->appendInst(
           InstIcmp::create(Func, InstIcmp::Slt, TmpDest, Left, Right));
       Control()->appendInst(
-          InstCast::create(Func, InstCast::Sext, Dest, TmpDest));
+          InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
       break;
     }
     case kExprI32LeS:
     case kExprI64LeS: {
       auto *TmpDest = makeVariable(IceType_i1);
       Control()->appendInst(
           InstIcmp::create(Func, InstIcmp::Sle, TmpDest, Left, Right));
       Control()->appendInst(
-          InstCast::create(Func, InstCast::Sext, Dest, TmpDest));
+          InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
       break;
     }
     case kExprI32GeU:
     case kExprI64GeU: {
       auto *TmpDest = makeVariable(IceType_i1);
       Control()->appendInst(
           InstIcmp::create(Func, InstIcmp::Uge, TmpDest, Left, Right));
       Control()->appendInst(
-          InstCast::create(Func, InstCast::Sext, Dest, TmpDest));
+          InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
       break;
     }
     case kExprI32LeU:
     case kExprI64LeU: {
       auto *TmpDest = makeVariable(IceType_i1);
       Control()->appendInst(
           InstIcmp::create(Func, InstIcmp::Ule, TmpDest, Left, Right));
       Control()->appendInst(
-          InstCast::create(Func, InstCast::Sext, Dest, TmpDest));
+          InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
       break;
     }
     case kExprI32LtU:
     case kExprI64LtU: {
       auto *TmpDest = makeVariable(IceType_i1);
       Control()->appendInst(
           InstIcmp::create(Func, InstIcmp::Ult, TmpDest, Left, Right));
       Control()->appendInst(
-          InstCast::create(Func, InstCast::Sext, Dest, TmpDest));
+          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::Sext, Dest, TmpDest));
+          InstCast::create(Func, InstCast::Zext, Dest, TmpDest));
     }
     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::Sext, Dest, TmpDest));
+          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::Sext, Dest, TmpDest));
+          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::Sext, Dest, TmpDest));
+          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::Sext, Dest, TmpDest));
+          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::Sext, Dest, Tmp));
+      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 kExprF32Neg: {
       Dest = makeVariable(IceType_f32);
       Control()->appendInst(InstArithmetic::create(
           Func, InstArithmetic::Fsub, Dest, Ctx->getConstantFloat(0), Input));
       break;
     }
     case kExprF64Neg: {
       Dest = makeVariable(IceType_f64);
@@ skipping 67 matching lines @@
     // save control here because true_node appears to alias control.
     auto *Ctrl = Control();
 
     *TrueNode = OperandNode(Func->makeNode());
     *FalseNode = OperandNode(Func->makeNode());
 
     LOG(out << *TrueNode << ", " << *FalseNode << ")"
             << "\n");
 
     auto *CondBool = makeVariable(IceType_i1);
-    Ctrl->appendInst(InstCast::create(Func, InstCast::Trunc, CondBool, Cond));
+    Ctrl->appendInst(InstIcmp::create(Func, InstIcmp::Ne, CondBool, Cond,
+                                      Ctx->getConstantInt32(0)));
 
     Ctrl->appendInst(InstBr::create(Func, CondBool, *TrueNode, *FalseNode));
     return OperandNode(nullptr);
   }
   InstSwitch *CurrentSwitch = nullptr;
   CfgNode *SwitchNode = nullptr;
   SizeT SwitchIndex = 0;
   Node Switch(uint32_t Count, Node Key) {
     LOG(out << "Switch(" << Count << ", " << Key << ")\n");
 
@@ skipping 204 matching lines @@
     (void)Index;
     llvm::report_fatal_error("LoadGlobal");
   }
   Node StoreGlobal(uint32_t Index, Node Val) {
     (void)Index;
     (void)Val;
     llvm::report_fatal_error("StoreGlobal");
   }
 
   Operand *sanitizeAddress(Operand *Base, uint32_t Offset) {
+    SizeT MemSize = Module->module->min_mem_pages * WASM_PAGE_SIZE;
+    SizeT MemMask = MemSize - 1;
+
+    bool ConstZeroBase = false;
+
     // first, add the index and the offset together.
-    if (0 != Offset) {
-      auto *Addr = makeVariable(IceType_i32);
+    if (auto *ConstBase = llvm::dyn_cast<ConstantInteger32>(Base)) {
+      uint32_t RealOffset = Offset + ConstBase->getValue();
+      RealOffset &= MemMask;
+      Base = Ctx->getConstantInt32(RealOffset);
+      ConstZeroBase = (0 == RealOffset);
+    } else if (0 != Offset) {
+      auto *Addr = makeVariable(Ice::getPointerType());
       auto *OffsetConstant = Ctx->getConstantInt32(Offset);
       Control()->appendInst(InstArithmetic::create(Func, InstArithmetic::Add,
                                                    Addr, Base, OffsetConstant));
+
       Base = Addr;
     }
 
-    SizeT MemSize = Module->module->min_mem_pages * (16 << 10);
-    auto *WrappedAddr = makeVariable(IceType_i32);
-    Control()->appendInst(
-        InstArithmetic::create(Func, InstArithmetic::Add, WrappedAddr, Base,
-                               Ctx->getConstantInt32(MemSize)));
+    if (!llvm::dyn_cast<ConstantInteger32>(Base)) {
+      auto *ClampedAddr = makeVariable(Ice::getPointerType());
+      Control()->appendInst(
+          InstArithmetic::create(Func, InstArithmetic::And, ClampedAddr, Base,
+                                 Ctx->getConstantInt32(MemSize - 1)));
+      Base = ClampedAddr;
+    }
 
-    auto ClampedAddr = makeVariable(IceType_i32);
-    Control()->appendInst(
-        InstArithmetic::create(Func, InstArithmetic::And, ClampedAddr, Base,
-                               Ctx->getConstantInt32(MemSize - 1)));
+    Ice::Operand *RealAddr = nullptr;
+    auto MemBase = Ctx->getConstantSym(0, Ctx->getGlobalString("WASM_MEMORY"));
+    if (!ConstZeroBase) {
+      auto RealAddrV = Func->makeVariable(Ice::getPointerType());
+      Control()->appendInst(InstArithmetic::create(
+          Func, InstArithmetic::Add, RealAddrV, Base, MemBase));
 
-    auto RealAddr = Func->makeVariable(IceType_i32);
-    auto MemBase = Ctx->getConstantSym(0, Ctx->getGlobalString("WASM_MEMORY"));
-    Control()->appendInst(InstArithmetic::create(
-        Func, InstArithmetic::Add, RealAddr, ClampedAddr, MemBase));
+      RealAddr = RealAddrV;
+    } else {
+      RealAddr = MemBase;
+    }
     return RealAddr;
   }
 
   Node LoadMem(wasm::LocalType Type, MachineType MemType, Node Index,
                uint32_t Offset) {
     LOG(out << "LoadMem(" << Index << "[" << Offset << "]) = ");
 
     auto *RealAddr = sanitizeAddress(Index, Offset);
 
     auto *LoadResult = makeVariable(toIceType(MemType));
@@ skipping 271 matching lines @@
       // Add the data
       WasmMemory->addInitializer(VariableDeclaration::DataInitializer::create(
           Globals.get(), reinterpret_cast<const char *>(Module->module_start) +
                              Seg.source_offset,
           Seg.source_size));
 
       WritePtr += Seg.source_size;
     }
 
     // Pad the rest with zeros
-    SizeT DataSize = Module->min_mem_pages * (64 << 10);
+    SizeT DataSize = Module->min_mem_pages * WASM_PAGE_SIZE;
     if (WritePtr < DataSize) {
       WasmMemory->addInitializer(VariableDeclaration::ZeroInitializer::create(
           Globals.get(), DataSize - WritePtr));
     }
 
-    WasmMemory->addInitializer(VariableDeclaration::ZeroInitializer::create(
-        Globals.get(), Module->min_mem_pages * (64 << 10)));
-
     Globals->push_back(WasmMemory);
 
     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;
 
     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