diff --git a/iree/compiler/Dialect/HAL/Conversion/HALToVM/ConvertVariableOps.cpp b/iree/compiler/Dialect/HAL/Conversion/HALToVM/ConvertVariableOps.cpp
index 4315fc5..baa0db2 100644
--- a/iree/compiler/Dialect/HAL/Conversion/HALToVM/ConvertVariableOps.cpp
+++ b/iree/compiler/Dialect/HAL/Conversion/HALToVM/ConvertVariableOps.cpp
@@ -57,6 +57,30 @@
           op, op.sym_name(), op.is_mutable(), convertedType, op.initializer(),
           convertedValue, llvm::to_vector<4>(op->getDialectAttrs()));
       return success();
+    } else if (convertedType.isF32()) {
+      auto convertedValue = op.initial_value().hasValue()
+                                ? rewriter.getF32FloatAttr(static_cast<float>(
+                                      op.initial_value()
+                                          .getValue()
+                                          .cast<FloatAttr>()
+                                          .getValueAsDouble()))
+                                : Attribute{};
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalF32Op>(
+          op, op.sym_name(), op.is_mutable(), convertedType, op.initializer(),
+          convertedValue, llvm::to_vector<4>(op->getDialectAttrs()));
+      return success();
+    } else if (convertedType.isF64()) {
+      auto convertedValue =
+          op.initial_value().hasValue()
+              ? rewriter.getF64FloatAttr(op.initial_value()
+                                             .getValue()
+                                             .cast<FloatAttr>()
+                                             .getValueAsDouble())
+              : Attribute{};
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalF64Op>(
+          op, op.sym_name(), op.is_mutable(), convertedType, op.initializer(),
+          convertedValue, llvm::to_vector<4>(op->getDialectAttrs()));
+      return success();
     }
     return op.emitOpError("unsupported variable type");
   }
@@ -93,12 +117,25 @@
   LogicalResult matchAndRewrite(
       IREE::HAL::VariableLoadOp op, llvm::ArrayRef<Value> operands,
       ConversionPatternRewriter &rewriter) const override {
-    if (IREE::VM::RefType::isCompatible(op.getType())) {
-      rewriter.replaceOpWithNewOp<IREE::VM::GlobalLoadRefOp>(
-          op, typeConverter.convertType(op.getType()), op.variable());
+    auto operandType = op.getType();
+    auto convertedType = typeConverter.convertType(operandType);
+    if (IREE::VM::RefType::isCompatible(operandType)) {
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalLoadRefOp>(op, convertedType,
+                                                             op.variable());
+    } else if (convertedType.isInteger(32)) {
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalLoadI32Op>(op, convertedType,
+                                                             op.variable());
+    } else if (convertedType.isInteger(64)) {
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalLoadI64Op>(op, convertedType,
+                                                             op.variable());
+    } else if (convertedType.isF32()) {
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalLoadF32Op>(op, convertedType,
+                                                             op.variable());
+    } else if (convertedType.isF64()) {
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalLoadF64Op>(op, convertedType,
+                                                             op.variable());
     } else {
-      rewriter.replaceOpWithNewOp<IREE::VM::GlobalLoadI32Op>(
-          op, typeConverter.convertType(op.getType()), op.variable());
+      return rewriter.notifyMatchFailure(op, "unhandled variable type");
     }
     return success();
   }
@@ -115,15 +152,27 @@
       : OpConversionPattern(context), typeConverter(typeConverter) {}
 
   LogicalResult matchAndRewrite(
-      IREE::HAL::VariableLoadIndirectOp op, llvm::ArrayRef<Value> newOperands,
+      IREE::HAL::VariableLoadIndirectOp op, llvm::ArrayRef<Value> operands,
       ConversionPatternRewriter &rewriter) const override {
-    IREE::HAL::VariableLoadIndirectOp::Adaptor operands(newOperands);
-    if (IREE::VM::RefType::isCompatible(op.getType())) {
+    auto operandType = op.getType();
+    auto convertedType = typeConverter.convertType(operandType);
+    if (IREE::VM::RefType::isCompatible(operandType)) {
       rewriter.replaceOpWithNewOp<IREE::VM::GlobalLoadIndirectRefOp>(
-          op, typeConverter.convertType(op.getType()), operands.variable());
-    } else {
+          op, convertedType, op.variable());
+    } else if (convertedType.isInteger(32)) {
       rewriter.replaceOpWithNewOp<IREE::VM::GlobalLoadIndirectI32Op>(
-          op, typeConverter.convertType(op.getType()), operands.variable());
+          op, convertedType, op.variable());
+    } else if (convertedType.isInteger(64)) {
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalLoadIndirectI64Op>(
+          op, convertedType, op.variable());
+    } else if (convertedType.isF32()) {
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalLoadIndirectF32Op>(
+          op, convertedType, op.variable());
+    } else if (convertedType.isF64()) {
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalLoadIndirectF64Op>(
+          op, convertedType, op.variable());
+    } else {
+      return rewriter.notifyMatchFailure(op, "unhandled variable type");
     }
     return success();
   }
@@ -142,12 +191,24 @@
       IREE::HAL::VariableStoreOp op, llvm::ArrayRef<Value> newOperands,
       ConversionPatternRewriter &rewriter) const override {
     IREE::HAL::VariableStoreOp::Adaptor operands(newOperands);
-    if (operands.value().getType().isa<IREE::VM::RefType>()) {
+    auto operandType = operands.value().getType();
+    if (operandType.isa<IREE::VM::RefType>()) {
       rewriter.replaceOpWithNewOp<IREE::VM::GlobalStoreRefOp>(
           op, operands.value(), op.variable());
-    } else {
+    } else if (operandType.isInteger(32)) {
       rewriter.replaceOpWithNewOp<IREE::VM::GlobalStoreI32Op>(
           op, operands.value(), op.variable());
+    } else if (operandType.isInteger(64)) {
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalStoreI64Op>(
+          op, operands.value(), op.variable());
+    } else if (operandType.isF32()) {
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalStoreF32Op>(
+          op, operands.value(), op.variable());
+    } else if (operandType.isF64()) {
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalStoreF64Op>(
+          op, operands.value(), op.variable());
+    } else {
+      return rewriter.notifyMatchFailure(op, "unhandled variable type");
     }
     return success();
   }
@@ -164,12 +225,24 @@
       IREE::HAL::VariableStoreIndirectOp op, llvm::ArrayRef<Value> newOperands,
       ConversionPatternRewriter &rewriter) const override {
     IREE::HAL::VariableStoreIndirectOp::Adaptor operands(newOperands);
-    if (operands.value().getType().isa<IREE::VM::RefType>()) {
+    auto operandType = operands.value().getType();
+    if (operandType.isa<IREE::VM::RefType>()) {
       rewriter.replaceOpWithNewOp<IREE::VM::GlobalStoreIndirectRefOp>(
-          op, operands.value(), operands.variable());
-    } else {
+          op, operands.value(), op.variable());
+    } else if (operandType.isInteger(32)) {
       rewriter.replaceOpWithNewOp<IREE::VM::GlobalStoreIndirectI32Op>(
-          op, operands.value(), operands.variable());
+          op, operands.value(), op.variable());
+    } else if (operandType.isInteger(64)) {
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalStoreIndirectI64Op>(
+          op, operands.value(), op.variable());
+    } else if (operandType.isF32()) {
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalStoreIndirectF32Op>(
+          op, operands.value(), op.variable());
+    } else if (operandType.isF64()) {
+      rewriter.replaceOpWithNewOp<IREE::VM::GlobalStoreIndirectF64Op>(
+          op, operands.value(), op.variable());
+    } else {
+      return rewriter.notifyMatchFailure(op, "unhandled variable type");
     }
     return success();
   }
diff --git a/iree/compiler/Dialect/VM/Conversion/IREEToVM/ConvertIREEToVM.cpp b/iree/compiler/Dialect/VM/Conversion/IREEToVM/ConvertIREEToVM.cpp
index f49e8f2..2f8b606 100644
--- a/iree/compiler/Dialect/VM/Conversion/IREEToVM/ConvertIREEToVM.cpp
+++ b/iree/compiler/Dialect/VM/Conversion/IREEToVM/ConvertIREEToVM.cpp
@@ -75,9 +75,8 @@
       ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<IREE::VM::FailOp>(
         srcOp,
-        rewriter.createOrFold<mlir::ConstantIntOp>(
-            srcOp.getLoc(), static_cast<int32_t>(IREE::StatusCode::Unknown),
-            32),
+        rewriter.createOrFold<IREE::VM::ConstI32Op>(
+            srcOp.getLoc(), static_cast<int32_t>(IREE::StatusCode::Unknown)),
         srcOp.message());
     return success();
   }
@@ -138,6 +137,12 @@
     } else if (resultType.isInteger(64)) {
       rewriter.replaceOpWithNewOp<IREE::VM::ListGetI64Op>(
           srcOp, resultType, srcOperands.list(), srcOperands.index());
+    } else if (resultType.isF32()) {
+      rewriter.replaceOpWithNewOp<IREE::VM::ListGetF32Op>(
+          srcOp, resultType, srcOperands.list(), srcOperands.index());
+    } else if (resultType.isF64()) {
+      rewriter.replaceOpWithNewOp<IREE::VM::ListGetF64Op>(
+          srcOp, resultType, srcOperands.list(), srcOperands.index());
     } else if (!resultType.isIntOrIndexOrFloat()) {
       rewriter.replaceOpWithNewOp<IREE::VM::ListGetRefOp>(
           srcOp, resultType, srcOperands.list(), srcOperands.index());
@@ -161,6 +166,12 @@
     } else if (valueType.isInteger(64)) {
       rewriter.replaceOpWithNewOp<IREE::VM::ListSetI64Op>(
           srcOp, srcOperands.list(), srcOperands.index(), srcOperands.value());
+    } else if (valueType.isF32()) {
+      rewriter.replaceOpWithNewOp<IREE::VM::ListSetF32Op>(
+          srcOp, srcOperands.list(), srcOperands.index(), srcOperands.value());
+    } else if (valueType.isF64()) {
+      rewriter.replaceOpWithNewOp<IREE::VM::ListSetF64Op>(
+          srcOp, srcOperands.list(), srcOperands.index(), srcOperands.value());
     } else if (!valueType.isIntOrIndexOrFloat()) {
       rewriter.replaceOpWithNewOp<IREE::VM::ListSetRefOp>(
           srcOp, srcOperands.list(), srcOperands.index(), srcOperands.value());
diff --git a/iree/compiler/Dialect/VM/Conversion/StandardToVM/ConvertStandardToVM.cpp b/iree/compiler/Dialect/VM/Conversion/StandardToVM/ConvertStandardToVM.cpp
index d5e6317..eb98d42 100644
--- a/iree/compiler/Dialect/VM/Conversion/StandardToVM/ConvertStandardToVM.cpp
+++ b/iree/compiler/Dialect/VM/Conversion/StandardToVM/ConvertStandardToVM.cpp
@@ -160,35 +160,61 @@
   LogicalResult matchAndRewrite(
       ConstantOp srcOp, ArrayRef<Value> operands,
       ConversionPatternRewriter &rewriter) const override {
-    auto integerAttr = srcOp.getValue().dyn_cast<IntegerAttr>();
-    if (!integerAttr) {
-      return srcOp.emitRemark() << "unsupported const type for dialect";
-    }
     // TODO(#2878): use getTypeConverter() when we pass it upon creation.
     IREE::VM::TypeConverter typeConverter(
         IREE::VM::getTargetOptionsFromFlags());
     auto targetType = typeConverter.convertType(srcOp.getType());
-    switch (targetType.getIntOrFloatBitWidth()) {
-      case 1:
-      case 32:
-        if (integerAttr.getInt()) {
-          rewriter.replaceOpWithNewOp<IREE::VM::ConstI32Op>(
-              srcOp, integerAttr.getInt());
-        } else {
-          rewriter.replaceOpWithNewOp<IREE::VM::ConstI32ZeroOp>(srcOp);
-        }
-        break;
-      case 64:
-        if (integerAttr.getInt()) {
-          rewriter.replaceOpWithNewOp<IREE::VM::ConstI64Op>(
-              srcOp, integerAttr.getInt());
-        } else {
-          rewriter.replaceOpWithNewOp<IREE::VM::ConstI64ZeroOp>(srcOp);
-        }
-        break;
-      default:
-        return srcOp.emitRemark()
-               << "unsupported const integer bit width for dialect";
+    if (targetType.isa<IntegerType>()) {
+      auto integerAttr = srcOp.getValue().dyn_cast<IntegerAttr>();
+      if (!integerAttr) {
+        return srcOp.emitRemark() << "unsupported const type for dialect";
+      }
+      switch (targetType.getIntOrFloatBitWidth()) {
+        case 1:
+        case 32:
+          if (integerAttr.getInt()) {
+            rewriter.replaceOpWithNewOp<IREE::VM::ConstI32Op>(
+                srcOp, integerAttr.getInt());
+          } else {
+            rewriter.replaceOpWithNewOp<IREE::VM::ConstI32ZeroOp>(srcOp);
+          }
+          break;
+        case 64:
+          if (integerAttr.getInt()) {
+            rewriter.replaceOpWithNewOp<IREE::VM::ConstI64Op>(
+                srcOp, integerAttr.getInt());
+          } else {
+            rewriter.replaceOpWithNewOp<IREE::VM::ConstI64ZeroOp>(srcOp);
+          }
+          break;
+        default:
+          return srcOp.emitRemark()
+                 << "unsupported const integer bit width for dialect";
+      }
+    } else if (targetType.isa<FloatType>()) {
+      auto floatAttr = srcOp.getValue().dyn_cast<FloatAttr>();
+      if (!floatAttr) {
+        return srcOp.emitRemark() << "unsupported const type for dialect";
+      }
+      switch (targetType.getIntOrFloatBitWidth()) {
+        case 32:
+          if (floatAttr.getValue().isZero()) {
+            rewriter.replaceOpWithNewOp<IREE::VM::ConstF32ZeroOp>(srcOp);
+          } else {
+            rewriter.replaceOpWithNewOp<IREE::VM::ConstF32Op>(srcOp, floatAttr);
+          }
+          break;
+        case 64:
+          if (floatAttr.getValue().isZero()) {
+            rewriter.replaceOpWithNewOp<IREE::VM::ConstF64ZeroOp>(srcOp);
+          } else {
+            rewriter.replaceOpWithNewOp<IREE::VM::ConstF64Op>(srcOp, floatAttr);
+          }
+          break;
+        default:
+          return srcOp.emitRemark()
+                 << "unsupported const floating-point bit width for dialect";
+      }
     }
     return success();
   }
@@ -200,48 +226,48 @@
   LogicalResult matchAndRewrite(
       CmpIOp srcOp, ArrayRef<Value> operands,
       ConversionPatternRewriter &rewriter) const override {
-    CmpIOp::Adaptor srcAdapter(operands);
+    CmpIOp::Adaptor srcAdaptor(operands);
     auto returnType = rewriter.getIntegerType(32);
     switch (srcOp.getPredicate()) {
       case CmpIPredicate::eq:
         rewriter.replaceOpWithNewOp<IREE::VM::CmpEQI32Op>(
-            srcOp, returnType, srcAdapter.lhs(), srcAdapter.rhs());
+            srcOp, returnType, srcAdaptor.lhs(), srcAdaptor.rhs());
         return success();
       case CmpIPredicate::ne:
         rewriter.replaceOpWithNewOp<IREE::VM::CmpNEI32Op>(
-            srcOp, returnType, srcAdapter.lhs(), srcAdapter.rhs());
+            srcOp, returnType, srcAdaptor.lhs(), srcAdaptor.rhs());
         return success();
       case CmpIPredicate::slt:
         rewriter.replaceOpWithNewOp<IREE::VM::CmpLTI32SOp>(
-            srcOp, returnType, srcAdapter.lhs(), srcAdapter.rhs());
+            srcOp, returnType, srcAdaptor.lhs(), srcAdaptor.rhs());
         return success();
       case CmpIPredicate::sle:
         rewriter.replaceOpWithNewOp<IREE::VM::CmpLTEI32SOp>(
-            srcOp, returnType, srcAdapter.lhs(), srcAdapter.rhs());
+            srcOp, returnType, srcAdaptor.lhs(), srcAdaptor.rhs());
         return success();
       case CmpIPredicate::sgt:
         rewriter.replaceOpWithNewOp<IREE::VM::CmpGTI32SOp>(
-            srcOp, returnType, srcAdapter.lhs(), srcAdapter.rhs());
+            srcOp, returnType, srcAdaptor.lhs(), srcAdaptor.rhs());
         return success();
       case CmpIPredicate::sge:
         rewriter.replaceOpWithNewOp<IREE::VM::CmpGTEI32SOp>(
-            srcOp, returnType, srcAdapter.lhs(), srcAdapter.rhs());
+            srcOp, returnType, srcAdaptor.lhs(), srcAdaptor.rhs());
         return success();
       case CmpIPredicate::ult:
         rewriter.replaceOpWithNewOp<IREE::VM::CmpLTI32UOp>(
-            srcOp, returnType, srcAdapter.lhs(), srcAdapter.rhs());
+            srcOp, returnType, srcAdaptor.lhs(), srcAdaptor.rhs());
         return success();
       case CmpIPredicate::ule:
         rewriter.replaceOpWithNewOp<IREE::VM::CmpLTEI32UOp>(
-            srcOp, returnType, srcAdapter.lhs(), srcAdapter.rhs());
+            srcOp, returnType, srcAdaptor.lhs(), srcAdaptor.rhs());
         return success();
       case CmpIPredicate::ugt:
         rewriter.replaceOpWithNewOp<IREE::VM::CmpGTI32UOp>(
-            srcOp, returnType, srcAdapter.lhs(), srcAdapter.rhs());
+            srcOp, returnType, srcAdaptor.lhs(), srcAdaptor.rhs());
         return success();
       case CmpIPredicate::uge:
         rewriter.replaceOpWithNewOp<IREE::VM::CmpGTEI32UOp>(
-            srcOp, returnType, srcAdapter.lhs(), srcAdapter.rhs());
+            srcOp, returnType, srcAdaptor.lhs(), srcAdaptor.rhs());
         return success();
       default:
         return failure();
@@ -249,17 +275,28 @@
   }
 };
 
-template <typename SrcOpTy, typename DstOpTy>
+template <typename SrcOpTy, typename Dst32OpTy, typename Dst64OpTy>
 class BinaryArithmeticOpConversion : public OpConversionPattern<SrcOpTy> {
   using OpConversionPattern<SrcOpTy>::OpConversionPattern;
 
   LogicalResult matchAndRewrite(
       SrcOpTy srcOp, ArrayRef<Value> operands,
       ConversionPatternRewriter &rewriter) const override {
-    typename SrcOpTy::Adaptor srcAdapter(operands);
-
-    rewriter.replaceOpWithNewOp<DstOpTy>(srcOp, srcAdapter.lhs().getType(),
-                                         srcAdapter.lhs(), srcAdapter.rhs());
+    typename SrcOpTy::Adaptor srcAdaptor(operands);
+    switch (srcAdaptor.lhs().getType().getIntOrFloatBitWidth()) {
+      case 32:
+        rewriter.replaceOpWithNewOp<Dst32OpTy>(
+            srcOp, srcAdaptor.lhs().getType(), srcAdaptor.lhs(),
+            srcAdaptor.rhs());
+        break;
+      case 64:
+        rewriter.replaceOpWithNewOp<Dst64OpTy>(
+            srcOp, srcAdaptor.lhs().getType(), srcAdaptor.lhs(),
+            srcAdaptor.rhs());
+        break;
+      default:
+        llvm_unreachable("invalid target type");
+    }
     return success();
   }
 };
@@ -302,28 +339,37 @@
   }
 };
 
-class SelectI32OpConversion : public OpConversionPattern<SelectOp> {
+class SelectOpConversion : public OpConversionPattern<SelectOp> {
   using OpConversionPattern::OpConversionPattern;
   LogicalResult matchAndRewrite(
       SelectOp srcOp, ArrayRef<Value> operands,
       ConversionPatternRewriter &rewriter) const override {
     SelectOp::Adaptor srcAdaptor(operands);
-    IntegerType requiredType = IntegerType::get(srcOp.getContext(), 32);
-    // Note: This check can correctly just be a verification that
-    // actualType == requiredType, but since the VM type conversion also
-    // maps Indextype to this type, widening the check here reduces red-herrings
-    // when other conversions fail to properly match/rewrite index related ops.
-    // (Otherwise, the dialect converter may report the error as a failure to
-    // legalize the select op depending on order of resolution).
-    auto actualType = srcAdaptor.true_value().getType();
-    if (actualType != requiredType && actualType.isa<IndexType>()) {
-      return failure();
+    auto valueType = srcAdaptor.true_value().getType();
+    if (valueType.isInteger(32)) {
+      rewriter.replaceOpWithNewOp<IREE::VM::SelectI32Op>(
+          srcOp, valueType, srcAdaptor.condition(), srcAdaptor.true_value(),
+          srcAdaptor.false_value());
+      return success();
+    } else if (valueType.isInteger(64)) {
+      rewriter.replaceOpWithNewOp<IREE::VM::SelectI64Op>(
+          srcOp, valueType, srcAdaptor.condition(), srcAdaptor.true_value(),
+          srcAdaptor.false_value());
+      return success();
+    } else if (valueType.isF32()) {
+      rewriter.replaceOpWithNewOp<IREE::VM::SelectF32Op>(
+          srcOp, valueType, srcAdaptor.condition(), srcAdaptor.true_value(),
+          srcAdaptor.false_value());
+      return success();
+    } else if (valueType.isF64()) {
+      rewriter.replaceOpWithNewOp<IREE::VM::SelectF64Op>(
+          srcOp, valueType, srcAdaptor.condition(), srcAdaptor.true_value(),
+          srcAdaptor.false_value());
+      return success();
+    } else {
+      return rewriter.notifyMatchFailure(srcOp,
+                                         "unsupported select element type");
     }
-
-    rewriter.replaceOpWithNewOp<IREE::VM::SelectI32Op>(
-        srcOp, requiredType, srcAdaptor.condition(), srcAdaptor.true_value(),
-        srcAdaptor.false_value());
-    return success();
   }
 };
 
@@ -386,24 +432,45 @@
   patterns.insert<BranchOpConversion, CallOpConversion, CmpIOpConversion,
                   CondBranchOpConversion, ModuleOpConversion, FuncOpConversion,
                   ReturnOpConversion, CastingOpConversion<IndexCastOp>,
-                  CastingOpConversion<TruncateIOp>, SelectI32OpConversion>(
+                  CastingOpConversion<TruncateIOp>, SelectOpConversion>(
       typeConverter, context);
   // TODO(#2878): pass typeConverter here.
   patterns.insert<ConstantOpConversion>(context);
 
-  // Binary arithmetic ops
-  patterns
-      .insert<BinaryArithmeticOpConversion<AddIOp, IREE::VM::AddI32Op>,
-              BinaryArithmeticOpConversion<SignedDivIOp, IREE::VM::DivI32SOp>,
-              BinaryArithmeticOpConversion<UnsignedDivIOp, IREE::VM::DivI32UOp>,
-              BinaryArithmeticOpConversion<MulIOp, IREE::VM::MulI32Op>,
-              BinaryArithmeticOpConversion<SignedRemIOp, IREE::VM::RemI32SOp>,
-              BinaryArithmeticOpConversion<UnsignedRemIOp, IREE::VM::RemI32UOp>,
-              BinaryArithmeticOpConversion<SubIOp, IREE::VM::SubI32Op>,
-              BinaryArithmeticOpConversion<AndOp, IREE::VM::AndI32Op>,
-              BinaryArithmeticOpConversion<OrOp, IREE::VM::OrI32Op>,
-              BinaryArithmeticOpConversion<XOrOp, IREE::VM::XorI32Op>>(
-          typeConverter, context);
+  // Integer arithmetic ops.
+  patterns.insert<
+      BinaryArithmeticOpConversion<AddIOp, IREE::VM::AddI32Op,
+                                   IREE::VM::AddI64Op>,
+      BinaryArithmeticOpConversion<SignedDivIOp, IREE::VM::DivI32SOp,
+                                   IREE::VM::DivI64SOp>,
+      BinaryArithmeticOpConversion<UnsignedDivIOp, IREE::VM::DivI32UOp,
+                                   IREE::VM::DivI64UOp>,
+      BinaryArithmeticOpConversion<MulIOp, IREE::VM::MulI32Op,
+                                   IREE::VM::MulI64Op>,
+      BinaryArithmeticOpConversion<SignedRemIOp, IREE::VM::RemI32SOp,
+                                   IREE::VM::RemI64SOp>,
+      BinaryArithmeticOpConversion<UnsignedRemIOp, IREE::VM::RemI32UOp,
+                                   IREE::VM::RemI64UOp>,
+      BinaryArithmeticOpConversion<SubIOp, IREE::VM::SubI32Op,
+                                   IREE::VM::SubI64Op>,
+      BinaryArithmeticOpConversion<AndOp, IREE::VM::AndI32Op,
+                                   IREE::VM::AndI64Op>,
+      BinaryArithmeticOpConversion<OrOp, IREE::VM::OrI32Op, IREE::VM::OrI64Op>,
+      BinaryArithmeticOpConversion<XOrOp, IREE::VM::XorI32Op,
+                                   IREE::VM::XorI64Op>>(typeConverter, context);
+
+  // Floating-point arithmetic ops.
+  patterns.insert<BinaryArithmeticOpConversion<AddFOp, IREE::VM::AddF32Op,
+                                               IREE::VM::AddF64Op>,
+                  BinaryArithmeticOpConversion<DivFOp, IREE::VM::DivF32Op,
+                                               IREE::VM::DivF64Op>,
+                  BinaryArithmeticOpConversion<MulFOp, IREE::VM::MulF32Op,
+                                               IREE::VM::MulF64Op>,
+                  BinaryArithmeticOpConversion<RemFOp, IREE::VM::RemF32Op,
+                                               IREE::VM::RemF64Op>,
+                  BinaryArithmeticOpConversion<SubFOp, IREE::VM::SubF32Op,
+                                               IREE::VM::SubF64Op>>(
+      typeConverter, context);
 
   // Shift ops
   // TODO(laurenzo): The standard dialect is missing shr ops. Add once in place.
diff --git a/iree/compiler/Dialect/VM/Conversion/TargetOptions.cpp b/iree/compiler/Dialect/VM/Conversion/TargetOptions.cpp
index 32f7513..7cb1218 100644
--- a/iree/compiler/Dialect/VM/Conversion/TargetOptions.cpp
+++ b/iree/compiler/Dialect/VM/Conversion/TargetOptions.cpp
@@ -37,7 +37,9 @@
       llvm::cl::desc("Supported target opcode extensions"),
       llvm::cl::cat(vmTargetOptionsCategory),
       llvm::cl::values(
-          clEnumValN(OpcodeExtension::kI64, "i64", "i64 type support")),
+          clEnumValN(OpcodeExtension::kI64, "i64", "i64 type support"),
+          clEnumValN(OpcodeExtension::kF32, "f32", "f32 type support"),
+          clEnumValN(OpcodeExtension::kF64, "f64", "f64 type support")),
   };
   static auto *truncateUnsupportedIntegersFlag = new llvm::cl::opt<bool>{
       "iree-vm-target-truncate-unsupported-integers",
@@ -45,6 +47,12 @@
       llvm::cl::desc("Truncate i64 to i32 when unsupported"),
       llvm::cl::cat(vmTargetOptionsCategory),
   };
+  static auto *truncateUnsupportedFloatsFlag = new llvm::cl::opt<bool>{
+      "iree-vm-target-truncate-unsupported-floats",
+      llvm::cl::init(true),
+      llvm::cl::desc("Truncate f64 to f32 when unsupported"),
+      llvm::cl::cat(vmTargetOptionsCategory),
+  };
 
   TargetOptions targetOptions;
   targetOptions.indexBits = *indexBitsFlag;
@@ -53,9 +61,16 @@
       case OpcodeExtension::kI64:
         targetOptions.i64Extension = true;
         break;
+      case OpcodeExtension::kF32:
+        targetOptions.f32Extension = true;
+        break;
+      case OpcodeExtension::kF64:
+        targetOptions.f64Extension = true;
+        break;
     }
   }
   targetOptions.truncateUnsupportedIntegers = *truncateUnsupportedIntegersFlag;
+  targetOptions.truncateUnsupportedFloats = *truncateUnsupportedFloatsFlag;
   return targetOptions;
 }
 
diff --git a/iree/compiler/Dialect/VM/Conversion/TargetOptions.h b/iree/compiler/Dialect/VM/Conversion/TargetOptions.h
index f68cab7..5f1973e 100644
--- a/iree/compiler/Dialect/VM/Conversion/TargetOptions.h
+++ b/iree/compiler/Dialect/VM/Conversion/TargetOptions.h
@@ -26,6 +26,10 @@
 enum class OpcodeExtension {
   // Adds ops for manipulating i64 types.
   kI64,
+  // Adds ops for manipulating f32 types.
+  kF32,
+  // Adds ops for manipulating f64 types.
+  kF64,
 };
 
 // Controls VM translation targets.
@@ -35,10 +39,20 @@
 
   // Whether the i64 extension is enabled in the target VM.
   bool i64Extension = false;
+  // Whether the f32 extension is enabled in the target VM.
+  bool f32Extension = false;
+  // Whether the f64 extension is enabled in the target VM.
+  bool f64Extension = false;
 
   // Whether to truncate i64 types to i32 when the i64 extension is not
   // enabled.
   bool truncateUnsupportedIntegers = true;
+  // Whether to truncate f64 types to f32 when the f64 extension is not
+  // enabled.
+  bool truncateUnsupportedFloats = true;
+
+  // Prefer optimizations that reduce VM stack usage over performance.
+  bool optimizeForStackSize = true;
 };
 
 // Returns a TargetOptions struct initialized with the
diff --git a/iree/compiler/Dialect/VM/Conversion/TypeConverter.cpp b/iree/compiler/Dialect/VM/Conversion/TypeConverter.cpp
index 0a27979..4054a3b 100644
--- a/iree/compiler/Dialect/VM/Conversion/TypeConverter.cpp
+++ b/iree/compiler/Dialect/VM/Conversion/TypeConverter.cpp
@@ -79,6 +79,37 @@
     return llvm::None;
   });
 
+  // Convert floating-point types.
+  addConversion([this](FloatType floatType) -> Optional<Type> {
+    if (floatType.getIntOrFloatBitWidth() < 32) {
+      if (targetOptions_.f32Extension) {
+        // Promote f16 -> f32.
+        return FloatType::getF32(floatType.getContext());
+      } else if (targetOptions_.truncateUnsupportedIntegers) {
+        // f32 is not supported; can't compile.
+        return llvm::None;
+      }
+    } else if (floatType.isF32()) {
+      if (targetOptions_.f32Extension) {
+        return floatType;
+      } else if (targetOptions_.truncateUnsupportedIntegers) {
+        // f32 is not supported; can't compile.
+        return llvm::None;
+      }
+    } else if (floatType.isF64()) {
+      if (targetOptions_.f64Extension) {
+        // f64 is supported by the VM, use directly.
+        return floatType;
+      } else if (targetOptions_.f32Extension &&
+                 targetOptions_.truncateUnsupportedFloats) {
+        // f64 is not supported and we still want to compile, so truncate to
+        // f32 (unsafe if all bits are actually required!).
+        return FloatType::getF32(floatType.getContext());
+      }
+    }
+    return llvm::None;
+  });
+
   // Convert index types to the target bit width.
   addConversion([this](IndexType indexType) -> Optional<Type> {
     return IntegerType::get(indexType.getContext(), targetOptions_.indexBits);
diff --git a/iree/compiler/Dialect/VM/IR/BUILD b/iree/compiler/Dialect/VM/IR/BUILD
index 05fc5b8..207dcd2 100644
--- a/iree/compiler/Dialect/VM/IR/BUILD
+++ b/iree/compiler/Dialect/VM/IR/BUILD
@@ -30,6 +30,8 @@
         [
             "VMBase.td",
             "VMOpcodesCore.td",
+            "VMOpcodesF32.td",
+            "VMOpcodesF64.td",
             "VMOpcodesI64.td",
             "VMOps.td",
         ],
diff --git a/iree/compiler/Dialect/VM/IR/VMBase.td b/iree/compiler/Dialect/VM/IR/VMBase.td
index 6cec68d..74760fd 100644
--- a/iree/compiler/Dialect/VM/IR/VMBase.td
+++ b/iree/compiler/Dialect/VM/IR/VMBase.td
@@ -56,8 +56,14 @@
 // Opcode tables
 //===----------------------------------------------------------------------===//
 
+// Mandatory:
 include "iree/compiler/Dialect/VM/IR/VMOpcodesCore.td"
+// Optional:
 include "iree/compiler/Dialect/VM/IR/VMOpcodesI64.td"
+// Optional:
+include "iree/compiler/Dialect/VM/IR/VMOpcodesF32.td"
+// Optional:
+include "iree/compiler/Dialect/VM/IR/VMOpcodesF64.td"
 
 //===----------------------------------------------------------------------===//
 // Declarative encoding framework
@@ -363,6 +369,14 @@
   let constBuilderCall = "$0";
 }
 
+class VM_ConstantFloatValueAttr<F type> :
+    FloatAttrBase<type, type.bitwidth # "-bit floating-point value"> {
+  let storageType = "FloatAttr";
+  let returnType = "FloatAttr";
+  let convertFromStorage = "$_self";
+  let constBuilderCall = "$0";
+}
+
 //===----------------------------------------------------------------------===//
 // VM structs
 //===----------------------------------------------------------------------===//
diff --git a/iree/compiler/Dialect/VM/IR/VMDialect.cpp b/iree/compiler/Dialect/VM/IR/VMDialect.cpp
index d2d796d..a5b6709 100644
--- a/iree/compiler/Dialect/VM/IR/VMDialect.cpp
+++ b/iree/compiler/Dialect/VM/IR/VMDialect.cpp
@@ -61,11 +61,18 @@
     }
     if (auto globalLoadOp = dyn_cast<GlobalLoadI32Op>(op)) {
       os << globalLoadOp.global();
+    } else if (auto globalLoadOp = dyn_cast<GlobalLoadI64Op>(op)) {
+      os << globalLoadOp.global();
+    } else if (auto globalLoadOp = dyn_cast<GlobalLoadF32Op>(op)) {
+      os << globalLoadOp.global();
+    } else if (auto globalLoadOp = dyn_cast<GlobalLoadF64Op>(op)) {
+      os << globalLoadOp.global();
     } else if (auto globalLoadOp = dyn_cast<GlobalLoadRefOp>(op)) {
       os << globalLoadOp.global();
     } else if (isa<ConstRefZeroOp>(op)) {
       os << "null";
-    } else if (isa<ConstI32ZeroOp>(op) || isa<ConstI64ZeroOp>(op)) {
+    } else if (isa<ConstI32ZeroOp>(op) || isa<ConstI64ZeroOp>(op) ||
+               isa<ConstF32ZeroOp>(op) || isa<ConstF64ZeroOp>(op)) {
       os << "zero";
     } else if (auto constOp = dyn_cast<ConstI32Op>(op)) {
       getIntegerName(constOp.value().dyn_cast<IntegerAttr>(), os);
@@ -319,6 +326,18 @@
       return builder.create<VM::ConstI64ZeroOp>(loc);
     }
     return builder.create<VM::ConstI64Op>(loc, convertedValue);
+  } else if (ConstF32Op::isBuildableWith(value, type)) {
+    auto convertedValue = ConstF32Op::convertConstValue(value);
+    if (convertedValue.cast<FloatAttr>().getValue().isZero()) {
+      return builder.create<VM::ConstF32ZeroOp>(loc);
+    }
+    return builder.create<VM::ConstF32Op>(loc, convertedValue);
+  } else if (ConstF64Op::isBuildableWith(value, type)) {
+    auto convertedValue = ConstF64Op::convertConstValue(value);
+    if (convertedValue.cast<FloatAttr>().getValue().isZero()) {
+      return builder.create<VM::ConstF64ZeroOp>(loc);
+    }
+    return builder.create<VM::ConstF64Op>(loc, convertedValue);
   } else if (type.isa<IREE::VM::RefType>()) {
     // The only constant type we support for refs is null so we can just
     // emit that here.
diff --git a/iree/compiler/Dialect/VM/IR/VMOpFolders.cpp b/iree/compiler/Dialect/VM/IR/VMOpFolders.cpp
index 246467b..47040d4 100644
--- a/iree/compiler/Dialect/VM/IR/VMOpFolders.cpp
+++ b/iree/compiler/Dialect/VM/IR/VMOpFolders.cpp
@@ -46,10 +46,11 @@
 /// Creates a constant one attribute matching the given type.
 Attribute oneOfType(Type type) {
   Builder builder(type.getContext());
-  if (type.isa<FloatType>()) return builder.getFloatAttr(type, 1.0);
-  if (auto integerTy = type.dyn_cast<IntegerType>())
+  if (type.isa<FloatType>()) {
+    return builder.getFloatAttr(type, 1.0);
+  } else if (auto integerTy = type.dyn_cast<IntegerType>()) {
     return builder.getIntegerAttr(integerTy, APInt(integerTy.getWidth(), 1));
-  if (type.isa<RankedTensorType, VectorType>()) {
+  } else if (type.isa<RankedTensorType, VectorType>()) {
     auto vtType = type.cast<ShapedType>();
     auto element = oneOfType(vtType.getElementType());
     if (!element) return {};
@@ -105,8 +106,12 @@
   LogicalResult matchAndRewrite(T op,
                                 PatternRewriter &rewriter) const override {
     if (!op.initial_value().hasValue()) return failure();
-    auto value = op.initial_valueAttr().template cast<IntegerAttr>();
-    if (value.getValue() != 0) return failure();
+    if (auto value = op.initial_valueAttr().template dyn_cast<IntegerAttr>()) {
+      if (value.getValue() != 0) return failure();
+    } else if (auto value =
+                   op.initial_valueAttr().template dyn_cast<FloatAttr>()) {
+      if (value.getValue().isNonZero()) return failure();
+    }
     rewriter.replaceOpWithNewOp<T>(op, op.sym_name(), op.is_mutable(),
                                    op.type(),
                                    llvm::to_vector<4>(op->getDialectAttrs()));
@@ -128,6 +133,18 @@
                  DropDefaultConstGlobalOpInitializer<GlobalI64Op>>(context);
 }
 
+void GlobalF32Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                              MLIRContext *context) {
+  results.insert<InlineConstGlobalOpInitializer<GlobalF32Op>,
+                 DropDefaultConstGlobalOpInitializer<GlobalF32Op>>(context);
+}
+
+void GlobalF64Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                              MLIRContext *context) {
+  results.insert<InlineConstGlobalOpInitializer<GlobalF64Op>,
+                 DropDefaultConstGlobalOpInitializer<GlobalF64Op>>(context);
+}
+
 void GlobalRefOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                               MLIRContext *context) {
   results.insert<InlineConstGlobalOpInitializer<GlobalRefOp>>(context);
@@ -174,6 +191,20 @@
       context);
 }
 
+void GlobalLoadF32Op::getCanonicalizationPatterns(
+    OwningRewritePatternList &results, MLIRContext *context) {
+  results.insert<InlineConstGlobalLoadIntegerOp<GlobalLoadF32Op, GlobalF32Op,
+                                                ConstF32Op, ConstF32ZeroOp>>(
+      context);
+}
+
+void GlobalLoadF64Op::getCanonicalizationPatterns(
+    OwningRewritePatternList &results, MLIRContext *context) {
+  results.insert<InlineConstGlobalLoadIntegerOp<GlobalLoadF64Op, GlobalF64Op,
+                                                ConstF64Op, ConstF64ZeroOp>>(
+      context);
+}
+
 namespace {
 
 /// Inlines immutable global constants into their loads.
@@ -233,6 +264,20 @@
       context);
 }
 
+void GlobalLoadIndirectF32Op::getCanonicalizationPatterns(
+    OwningRewritePatternList &results, MLIRContext *context) {
+  results.insert<
+      PropagateGlobalLoadAddress<GlobalLoadIndirectF32Op, GlobalLoadF32Op>>(
+      context);
+}
+
+void GlobalLoadIndirectF64Op::getCanonicalizationPatterns(
+    OwningRewritePatternList &results, MLIRContext *context) {
+  results.insert<
+      PropagateGlobalLoadAddress<GlobalLoadIndirectF64Op, GlobalLoadF64Op>>(
+      context);
+}
+
 void GlobalLoadIndirectRefOp::getCanonicalizationPatterns(
     OwningRewritePatternList &results, MLIRContext *context) {
   results.insert<
@@ -273,6 +318,20 @@
       context);
 }
 
+void GlobalStoreIndirectF32Op::getCanonicalizationPatterns(
+    OwningRewritePatternList &results, MLIRContext *context) {
+  results.insert<
+      PropagateGlobalStoreAddress<GlobalStoreIndirectF32Op, GlobalStoreF32Op>>(
+      context);
+}
+
+void GlobalStoreIndirectF64Op::getCanonicalizationPatterns(
+    OwningRewritePatternList &results, MLIRContext *context) {
+  results.insert<
+      PropagateGlobalStoreAddress<GlobalStoreIndirectF64Op, GlobalStoreF64Op>>(
+      context);
+}
+
 void GlobalStoreIndirectRefOp::getCanonicalizationPatterns(
     OwningRewritePatternList &results, MLIRContext *context) {
   results.insert<
@@ -287,7 +346,7 @@
 namespace {
 
 template <typename GeneralOp, typename ZeroOp>
-struct FoldZeroConstInteger final : public OpRewritePattern<GeneralOp> {
+struct FoldZeroConstPrimitive final : public OpRewritePattern<GeneralOp> {
   using OpRewritePattern<GeneralOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(GeneralOp constOp,
@@ -306,14 +365,28 @@
 
 void ConstI32Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                              MLIRContext *context) {
-  results.insert<FoldZeroConstInteger<ConstI32Op, ConstI32ZeroOp>>(context);
+  results.insert<FoldZeroConstPrimitive<ConstI32Op, ConstI32ZeroOp>>(context);
 }
 
 OpFoldResult ConstI64Op::fold(ArrayRef<Attribute> operands) { return value(); }
 
 void ConstI64Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                              MLIRContext *context) {
-  results.insert<FoldZeroConstInteger<ConstI64Op, ConstI64ZeroOp>>(context);
+  results.insert<FoldZeroConstPrimitive<ConstI64Op, ConstI64ZeroOp>>(context);
+}
+
+OpFoldResult ConstF32Op::fold(ArrayRef<Attribute> operands) { return value(); }
+
+void ConstF32Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                             MLIRContext *context) {
+  results.insert<FoldZeroConstPrimitive<ConstF32Op, ConstF32ZeroOp>>(context);
+}
+
+OpFoldResult ConstF64Op::fold(ArrayRef<Attribute> operands) { return value(); }
+
+void ConstF64Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                             MLIRContext *context) {
+  results.insert<FoldZeroConstPrimitive<ConstF64Op, ConstF64ZeroOp>>(context);
 }
 
 OpFoldResult ConstI32ZeroOp::fold(ArrayRef<Attribute> operands) {
@@ -324,6 +397,14 @@
   return IntegerAttr::get(getResult().getType(), 0);
 }
 
+OpFoldResult ConstF32ZeroOp::fold(ArrayRef<Attribute> operands) {
+  return FloatAttr::get(getResult().getType(), 0.0f);
+}
+
+OpFoldResult ConstF64ZeroOp::fold(ArrayRef<Attribute> operands) {
+  return FloatAttr::get(getResult().getType(), 0.0);
+}
+
 OpFoldResult ConstRefZeroOp::fold(ArrayRef<Attribute> operands) {
   // TODO(b/144027097): relace unit attr with a proper null ref attr.
   return UnitAttr::get(getContext());
@@ -360,6 +441,14 @@
   return foldSelectOp(*this);
 }
 
+OpFoldResult SelectF32Op::fold(ArrayRef<Attribute> operands) {
+  return foldSelectOp(*this);
+}
+
+OpFoldResult SelectF64Op::fold(ArrayRef<Attribute> operands) {
+  return foldSelectOp(*this);
+}
+
 OpFoldResult SelectRefOp::fold(ArrayRef<Attribute> operands) {
   return foldSelectOp(*this);
 }
@@ -400,19 +489,27 @@
   return foldSwitchOp(*this);
 }
 
+OpFoldResult SwitchF32Op::fold(ArrayRef<Attribute> operands) {
+  return foldSwitchOp(*this);
+}
+
+OpFoldResult SwitchF64Op::fold(ArrayRef<Attribute> operands) {
+  return foldSwitchOp(*this);
+}
+
 OpFoldResult SwitchRefOp::fold(ArrayRef<Attribute> operands) {
   return foldSwitchOp(*this);
 }
 
 //===----------------------------------------------------------------------===//
-// Native integer arithmetic
+// Integer arithmetic
 //===----------------------------------------------------------------------===//
 
 /// Performs const folding `calculate` with element-wise behavior on the given
 /// attribute in `operands` and returns the result if possible.
 template <class AttrElementT,
           class ElementValueT = typename AttrElementT::ValueType,
-          class CalculationT = std::function<ElementValueT(ElementValueT)>>
+          class CalculationT = std::function<APInt(ElementValueT)>>
 static Attribute constFoldUnaryOp(ArrayRef<Attribute> operands,
                                   const CalculationT &calculate) {
   assert(operands.size() == 1 && "unary op takes one operand");
@@ -432,6 +529,29 @@
   return {};
 }
 
+/// Performs const folding `calculate` with element-wise behavior on the given
+/// attribute in `operands` and returns the result if possible.
+static Attribute constFoldFloatUnaryOp(
+    ArrayRef<Attribute> operands,
+    const std::function<APFloat(APFloat)> &calculate) {
+  assert(operands.size() == 1 && "unary op takes one operand");
+  if (auto operand = operands[0].dyn_cast_or_null<FloatAttr>()) {
+    return FloatAttr::get(operand.getType(), calculate(operand.getValue()));
+  } else if (auto operand = operands[0].dyn_cast_or_null<SplatElementsAttr>()) {
+    auto elementResult =
+        constFoldFloatUnaryOp({operand.getSplatValue()}, calculate);
+    if (!elementResult) return {};
+    return DenseElementsAttr::get(operand.getType(), elementResult);
+  } else if (auto operand = operands[0].dyn_cast_or_null<ElementsAttr>()) {
+    return operand.mapValues(
+        operand.getType().getElementType(),
+        llvm::function_ref<APInt(const APFloat &)>([&](const APFloat &value) {
+          return calculate(value).bitcastToAPInt();
+        }));
+  }
+  return {};
+}
+
 /// Performs const folding `calculate` with element-wise behavior on the two
 /// attributes in `operands` and returns the result if possible.
 template <class AttrElementT,
@@ -472,7 +592,8 @@
   return {};
 }
 
-template <typename ADD, typename SUB>
+template <class AttrElementT, typename ADD, typename SUB,
+          class ElementValueT = typename AttrElementT::ValueType>
 static OpFoldResult foldAddOp(ADD op, ArrayRef<Attribute> operands) {
   if (matchPattern(op.rhs(), m_Zero())) {
     // x + 0 = x or 0 + y = y (commutative)
@@ -485,19 +606,21 @@
     if (subOp.lhs() == op.lhs()) return subOp.rhs();
     if (subOp.rhs() == op.lhs()) return subOp.lhs();
   }
-  return constFoldBinaryOp<IntegerAttr>(
-      operands, [](const APInt &a, const APInt &b) { return a + b; });
+  return constFoldBinaryOp<AttrElementT>(
+      operands,
+      [](const ElementValueT &a, const ElementValueT &b) { return a + b; });
 }
 
 OpFoldResult AddI32Op::fold(ArrayRef<Attribute> operands) {
-  return foldAddOp<AddI32Op, SubI32Op>(*this, operands);
+  return foldAddOp<IntegerAttr, AddI32Op, SubI32Op>(*this, operands);
 }
 
 OpFoldResult AddI64Op::fold(ArrayRef<Attribute> operands) {
-  return foldAddOp<AddI64Op, SubI64Op>(*this, operands);
+  return foldAddOp<IntegerAttr, AddI64Op, SubI64Op>(*this, operands);
 }
 
-template <typename SUB, typename ADD>
+template <class AttrElementT, typename SUB, typename ADD,
+          class ElementValueT = typename AttrElementT::ValueType>
 static OpFoldResult foldSubOp(SUB op, ArrayRef<Attribute> operands) {
   if (matchPattern(op.rhs(), m_Zero())) {
     // x - 0 = x
@@ -510,19 +633,21 @@
     if (addOp.lhs() == op.lhs()) return addOp.rhs();
     if (addOp.rhs() == op.lhs()) return addOp.lhs();
   }
-  return constFoldBinaryOp<IntegerAttr>(
-      operands, [](const APInt &a, const APInt &b) { return a - b; });
+  return constFoldBinaryOp<AttrElementT>(
+      operands,
+      [](const ElementValueT &a, const ElementValueT &b) { return a - b; });
 }
 
 OpFoldResult SubI32Op::fold(ArrayRef<Attribute> operands) {
-  return foldSubOp<SubI32Op, AddI32Op>(*this, operands);
+  return foldSubOp<IntegerAttr, SubI32Op, AddI32Op>(*this, operands);
 }
 
 OpFoldResult SubI64Op::fold(ArrayRef<Attribute> operands) {
-  return foldSubOp<SubI64Op, AddI64Op>(*this, operands);
+  return foldSubOp<IntegerAttr, SubI64Op, AddI64Op>(*this, operands);
 }
 
-template <typename T>
+template <class AttrElementT, typename T,
+          class ElementValueT = typename AttrElementT::ValueType>
 static OpFoldResult foldMulOp(T op, ArrayRef<Attribute> operands) {
   if (matchPattern(op.rhs(), m_Zero())) {
     // x * 0 = 0 or 0 * y = 0 (commutative)
@@ -531,25 +656,28 @@
     // x * 1 = x or 1 * y = y (commutative)
     return op.lhs();
   }
-  return constFoldBinaryOp<IntegerAttr>(
-      operands, [](const APInt &a, const APInt &b) { return a * b; });
+  return constFoldBinaryOp<AttrElementT>(
+      operands,
+      [](const ElementValueT &a, const ElementValueT &b) { return a * b; });
 }
 
-template <typename T, typename CONST_OP>
+template <class AttrElementT, typename T, typename CONST_OP,
+          class ElementValueT = typename AttrElementT::ValueType>
 struct FoldConstantMulOperand : public OpRewritePattern<T> {
   using OpRewritePattern<T>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(T op,
                                 PatternRewriter &rewriter) const override {
-    IntegerAttr c1, c2;
+    AttrElementT c1, c2;
     if (!matchPattern(op.rhs(), m_Constant(&c1))) return failure();
     if (auto mulOp = dyn_cast_or_null<T>(op.lhs().getDefiningOp())) {
       if (matchPattern(mulOp.rhs(), m_Constant(&c2))) {
         auto c = rewriter.createOrFold<CONST_OP>(
             rewriter.getFusedLoc({mulOp.getLoc(), op.getLoc()}),
-            constFoldBinaryOp<IntegerAttr>(
-                {c1, c2},
-                [](const APInt &a, const APInt &b) { return a * b; }));
+            constFoldBinaryOp<AttrElementT>(
+                {c1, c2}, [](const ElementValueT &a, const ElementValueT &b) {
+                  return a * b;
+                }));
         rewriter.replaceOpWithNewOp<T>(op, op.getType(), mulOp.lhs(), c);
         return success();
       }
@@ -559,21 +687,23 @@
 };
 
 OpFoldResult MulI32Op::fold(ArrayRef<Attribute> operands) {
-  return foldMulOp(*this, operands);
+  return foldMulOp<IntegerAttr>(*this, operands);
 }
 
 void MulI32Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                            MLIRContext *context) {
-  results.insert<FoldConstantMulOperand<MulI32Op, ConstI32Op>>(context);
+  results.insert<FoldConstantMulOperand<IntegerAttr, MulI32Op, ConstI32Op>>(
+      context);
 }
 
 OpFoldResult MulI64Op::fold(ArrayRef<Attribute> operands) {
-  return foldMulOp(*this, operands);
+  return foldMulOp<IntegerAttr>(*this, operands);
 }
 
 void MulI64Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                            MLIRContext *context) {
-  results.insert<FoldConstantMulOperand<MulI64Op, ConstI64Op>>(context);
+  results.insert<FoldConstantMulOperand<IntegerAttr, MulI64Op, ConstI64Op>>(
+      context);
 }
 
 template <typename T>
@@ -652,7 +782,12 @@
 
 template <typename T>
 static OpFoldResult foldRemUOp(T op, ArrayRef<Attribute> operands) {
-  if (matchPattern(op.lhs(), m_Zero()) || matchPattern(op.rhs(), m_One())) {
+  if (matchPattern(op.rhs(), m_Zero())) {
+    // x % 0 = death
+    op.emitOpError() << "is a remainder by constant zero";
+    return {};
+  } else if (matchPattern(op.lhs(), m_Zero()) ||
+             matchPattern(op.rhs(), m_One())) {
     // x % 1 = 0
     // 0 % y = 0
     return zeroOfType(op.getType());
@@ -669,6 +804,171 @@
   return foldRemUOp(*this, operands);
 }
 
+//===----------------------------------------------------------------------===//
+// Floating-point arithmetic
+//===----------------------------------------------------------------------===//
+
+OpFoldResult AddF32Op::fold(ArrayRef<Attribute> operands) {
+  return foldAddOp<FloatAttr, AddF32Op, SubF32Op>(*this, operands);
+}
+
+OpFoldResult AddF64Op::fold(ArrayRef<Attribute> operands) {
+  return foldAddOp<FloatAttr, AddF64Op, SubF64Op>(*this, operands);
+}
+
+OpFoldResult SubF32Op::fold(ArrayRef<Attribute> operands) {
+  return foldSubOp<FloatAttr, SubF32Op, AddF32Op>(*this, operands);
+}
+
+OpFoldResult SubF64Op::fold(ArrayRef<Attribute> operands) {
+  return foldSubOp<FloatAttr, SubF64Op, AddF64Op>(*this, operands);
+}
+
+OpFoldResult MulF32Op::fold(ArrayRef<Attribute> operands) {
+  return foldMulOp<FloatAttr>(*this, operands);
+}
+
+void MulF32Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                           MLIRContext *context) {
+  results.insert<FoldConstantMulOperand<FloatAttr, MulF32Op, ConstF32Op>>(
+      context);
+}
+
+OpFoldResult MulF64Op::fold(ArrayRef<Attribute> operands) {
+  return foldMulOp<FloatAttr>(*this, operands);
+}
+
+void MulF64Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                           MLIRContext *context) {
+  results.insert<FoldConstantMulOperand<FloatAttr, MulF64Op, ConstF64Op>>(
+      context);
+}
+
+template <typename T>
+static OpFoldResult foldDivFOp(T op, ArrayRef<Attribute> operands) {
+  if (matchPattern(op.rhs(), m_Zero())) {
+    // x / 0 = death
+    op.emitOpError() << "is a divide by constant zero";
+    return {};
+  } else if (matchPattern(op.lhs(), m_Zero())) {
+    // 0 / y = 0
+    return zeroOfType(op.getType());
+  } else if (matchPattern(op.rhs(), m_One())) {
+    // x / 1 = x
+    return op.lhs();
+  }
+  return constFoldBinaryOp<FloatAttr>(operands,
+                                      [](const APFloat &a, const APFloat &b) {
+                                        APFloat c = a;
+                                        c.divide(b, APFloat::rmTowardZero);
+                                        return c;
+                                      });
+}
+
+OpFoldResult DivF32Op::fold(ArrayRef<Attribute> operands) {
+  return foldDivFOp(*this, operands);
+}
+
+OpFoldResult DivF64Op::fold(ArrayRef<Attribute> operands) {
+  return foldDivFOp(*this, operands);
+}
+
+template <typename T>
+static OpFoldResult foldRemFOp(T op, ArrayRef<Attribute> operands) {
+  if (matchPattern(op.rhs(), m_Zero())) {
+    // x % 0 = death
+    op.emitOpError() << "is a remainder by constant zero";
+    return {};
+  } else if (matchPattern(op.lhs(), m_Zero()) ||
+             matchPattern(op.rhs(), m_One())) {
+    // x % 1 = 0
+    // 0 % y = 0
+    return zeroOfType(op.getType());
+  }
+  return constFoldBinaryOp<FloatAttr>(operands,
+                                      [](const APFloat &a, const APFloat &b) {
+                                        APFloat c = a;
+                                        c.remainder(b);
+                                        return c;
+                                      });
+}
+
+OpFoldResult RemF32Op::fold(ArrayRef<Attribute> operands) {
+  return foldRemFOp(*this, operands);
+}
+
+OpFoldResult RemF64Op::fold(ArrayRef<Attribute> operands) {
+  return foldRemFOp(*this, operands);
+}
+
+OpFoldResult AbsF32Op::fold(ArrayRef<Attribute> operands) {
+  return constFoldFloatUnaryOp(operands, [](const APFloat &a) {
+    auto b = a;
+    b.clearSign();
+    return b;
+  });
+}
+
+OpFoldResult AbsF64Op::fold(ArrayRef<Attribute> operands) {
+  return constFoldFloatUnaryOp(operands, [](const APFloat &a) {
+    auto b = a;
+    b.clearSign();
+    return b;
+  });
+}
+
+OpFoldResult NegF32Op::fold(ArrayRef<Attribute> operands) {
+  return constFoldFloatUnaryOp(operands, [](const APFloat &a) {
+    auto b = a;
+    b.changeSign();
+    return b;
+  });
+}
+
+OpFoldResult NegF64Op::fold(ArrayRef<Attribute> operands) {
+  return constFoldFloatUnaryOp(operands, [](const APFloat &a) {
+    auto b = a;
+    b.changeSign();
+    return b;
+  });
+}
+
+OpFoldResult CeilF32Op::fold(ArrayRef<Attribute> operands) {
+  return constFoldFloatUnaryOp(operands, [](const APFloat &a) {
+    auto b = a;
+    b.roundToIntegral(APFloat::rmTowardPositive);
+    return b;
+  });
+}
+
+OpFoldResult CeilF64Op::fold(ArrayRef<Attribute> operands) {
+  return constFoldFloatUnaryOp(operands, [](const APFloat &a) {
+    auto b = a;
+    b.roundToIntegral(APFloat::rmTowardPositive);
+    return b;
+  });
+}
+
+OpFoldResult FloorF32Op::fold(ArrayRef<Attribute> operands) {
+  return constFoldFloatUnaryOp(operands, [](const APFloat &a) {
+    auto b = a;
+    b.roundToIntegral(APFloat::rmTowardNegative);
+    return b;
+  });
+}
+
+OpFoldResult FloorF64Op::fold(ArrayRef<Attribute> operands) {
+  return constFoldFloatUnaryOp(operands, [](const APFloat &a) {
+    auto b = a;
+    b.roundToIntegral(APFloat::rmTowardNegative);
+    return b;
+  });
+}
+
+//===----------------------------------------------------------------------===//
+// Integer bit manipulation
+//===----------------------------------------------------------------------===//
+
 template <typename T>
 static OpFoldResult foldNotOp(T op, ArrayRef<Attribute> operands) {
   return constFoldUnaryOp<IntegerAttr>(operands, [](APInt a) {
@@ -864,6 +1164,12 @@
       [&](const APInt &a) { return a.trunc(32); });
 }
 
+OpFoldResult TruncF64F32Op::fold(ArrayRef<Attribute> operands) {
+  return constFoldConversionOp<FloatAttr>(
+      FloatType::getF32(getContext()), operands,
+      [&](const APFloat &a) { return APFloat(a.convertToFloat()); });
+}
+
 OpFoldResult ExtI8I32SOp::fold(ArrayRef<Attribute> operands) {
   return constFoldConversionOp<IntegerAttr>(
       IntegerType::get(getContext(), 32), operands,
@@ -924,6 +1230,12 @@
       [&](const APInt &a) { return a.zext(64); });
 }
 
+OpFoldResult ExtF32F64Op::fold(ArrayRef<Attribute> operands) {
+  return constFoldConversionOp<FloatAttr>(
+      FloatType::getF64(getContext()), operands,
+      [&](const APFloat &a) { return APFloat(a.convertToDouble()); });
+}
+
 namespace {
 
 template <typename SRC_OP, typename OP_A, int SZ_T, typename OP_B>
@@ -988,6 +1300,27 @@
 
 namespace {
 
+/// Performs const folding `calculate` with element-wise behavior on the given
+/// attribute in `operands` and returns the result if possible.
+template <class AttrElementT,
+          class ElementValueT = typename AttrElementT::ValueType,
+          class CalculationT = std::function<APInt(ElementValueT)>>
+static Attribute constFoldCmpOp(ArrayRef<Attribute> operands,
+                                const CalculationT &calculate) {
+  assert(operands.size() == 1 && "unary op takes one operand");
+  if (auto operand = operands[0].dyn_cast_or_null<AttrElementT>()) {
+    auto boolType = IntegerType::get(operand.getContext(), 32);
+    return IntegerAttr::get(boolType, calculate(operand.getValue()));
+  } else if (auto operand = operands[0].dyn_cast_or_null<ElementsAttr>()) {
+    auto boolType = IntegerType::get(operand.getContext(), 32);
+    return operand.mapValues(
+        boolType,
+        llvm::function_ref<APInt(const ElementValueT &)>(
+            [&](const ElementValueT &value) { return calculate(value); }));
+  }
+  return {};
+}
+
 /// Swaps the cmp op with its inverse if the result is inverted.
 template <typename OP, typename INV>
 struct SwapInvertedCmpOps : public OpRewritePattern<OP> {
@@ -1047,6 +1380,32 @@
 }
 
 template <typename T>
+static OpFoldResult foldCmpEQFOp(T op, ArrayRef<Attribute> operands) {
+  if (op.lhs() == op.rhs()) {
+    // x == x = true
+    return oneOfType(op.getType());
+  }
+  return constFoldBinaryOp<FloatAttr>(
+      operands, [&](const APFloat &a, const APFloat &b) {
+        return a.compare(b) == APFloat::cmpEqual;
+      });
+}
+
+OpFoldResult CmpEQF32Op::fold(ArrayRef<Attribute> operands) {
+  return foldCmpEQFOp(*this, operands);
+}
+
+void CmpEQF32Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                             MLIRContext *context) {}
+
+OpFoldResult CmpEQF64Op::fold(ArrayRef<Attribute> operands) {
+  return foldCmpEQFOp(*this, operands);
+}
+
+void CmpEQF64Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                             MLIRContext *context) {}
+
+template <typename T>
 static OpFoldResult foldCmpNEOp(T op, ArrayRef<Attribute> operands) {
   if (op.lhs() == op.rhs()) {
     // x != x = false
@@ -1064,6 +1423,26 @@
   return foldCmpNEOp(*this, operands);
 }
 
+template <typename T>
+static OpFoldResult foldCmpNEFOp(T op, ArrayRef<Attribute> operands) {
+  if (op.lhs() == op.rhs()) {
+    // x != x = false
+    return zeroOfType(op.getType());
+  }
+  return constFoldBinaryOp<FloatAttr>(
+      operands, [&](const APFloat &a, const APFloat &b) {
+        return a.compare(b) != APFloat::cmpEqual;
+      });
+}
+
+OpFoldResult CmpNEF32Op::fold(ArrayRef<Attribute> operands) {
+  return foldCmpNEFOp(*this, operands);
+}
+
+OpFoldResult CmpNEF64Op::fold(ArrayRef<Attribute> operands) {
+  return foldCmpNEFOp(*this, operands);
+}
+
 namespace {
 
 /// Changes a cmp.ne.i32 check against 0 to a cmp.nz.i32.
@@ -1094,6 +1473,18 @@
                  CmpNEZeroToCmpNZ<CmpNEI64Op, CmpNZI64Op>>(context);
 }
 
+void CmpNEF32Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                             MLIRContext *context) {
+  results.insert<SwapInvertedCmpOps<CmpNEF32Op, CmpEQF32Op>,
+                 CmpNEZeroToCmpNZ<CmpNEF32Op, CmpNZF32Op>>(context);
+}
+
+void CmpNEF64Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                             MLIRContext *context) {
+  results.insert<SwapInvertedCmpOps<CmpNEF64Op, CmpEQF64Op>,
+                 CmpNEZeroToCmpNZ<CmpNEF64Op, CmpNZF64Op>>(context);
+}
+
 template <typename T>
 static OpFoldResult foldCmpLTSOp(T op, ArrayRef<Attribute> operands) {
   if (op.lhs() == op.rhs()) {
@@ -1142,6 +1533,32 @@
 void CmpLTI64UOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                               MLIRContext *context) {}
 
+template <typename T>
+static OpFoldResult foldCmpLTFOp(T op, ArrayRef<Attribute> operands) {
+  if (op.lhs() == op.rhs()) {
+    // x < x = false
+    return zeroOfType(op.getType());
+  }
+  return constFoldBinaryOp<FloatAttr>(
+      operands, [&](const APFloat &a, const APFloat &b) {
+        return a.compare(b) == APFloat::cmpLessThan;
+      });
+}
+
+OpFoldResult CmpLTF32Op::fold(ArrayRef<Attribute> operands) {
+  return foldCmpLTFOp(*this, operands);
+}
+
+OpFoldResult CmpLTF64Op::fold(ArrayRef<Attribute> operands) {
+  return foldCmpLTFOp(*this, operands);
+}
+
+void CmpLTF32Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                             MLIRContext *context) {}
+
+void CmpLTF64Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                             MLIRContext *context) {}
+
 namespace {
 
 /// Rewrites a vm.cmp.lte.* pseudo op to a vm.cmp.lt.* op.
@@ -1222,6 +1639,39 @@
   results.insert<RewritePseudoCmpLTEToLT<CmpLTEI64UOp, CmpLTI64UOp>>(context);
 }
 
+template <typename T>
+static OpFoldResult foldCmpLTEFOp(T op, ArrayRef<Attribute> operands) {
+  if (op.lhs() == op.rhs()) {
+    // x <= x = true
+    return oneOfType(op.getType());
+  }
+  return constFoldBinaryOp<FloatAttr>(
+      operands, [&](const APFloat &a, const APFloat &b) {
+        return a.compare(b) == APFloat::cmpLessThan ||
+               a.compare(b) == APFloat::cmpEqual;
+      });
+}
+
+OpFoldResult CmpLTEF32Op::fold(ArrayRef<Attribute> operands) {
+  return foldCmpLTEFOp(*this, operands);
+}
+
+OpFoldResult CmpLTEF64Op::fold(ArrayRef<Attribute> operands) {
+  return foldCmpLTEFOp(*this, operands);
+}
+
+void CmpLTEF32Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                              MLIRContext *context) {
+  results.insert<SwapInvertedCmpOps<CmpLTEF32Op, CmpGTF32Op>>(context);
+  results.insert<RewritePseudoCmpLTEToLT<CmpLTEF32Op, CmpLTF32Op>>(context);
+}
+
+void CmpLTEF64Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                              MLIRContext *context) {
+  results.insert<SwapInvertedCmpOps<CmpLTEF64Op, CmpGTF64Op>>(context);
+  results.insert<RewritePseudoCmpLTEToLT<CmpLTEF64Op, CmpLTF64Op>>(context);
+}
+
 namespace {
 
 /// Rewrites a vm.cmp.gt.* pseudo op to a vm.cmp.lt.* op.
@@ -1298,6 +1748,38 @@
   results.insert<RewritePseudoCmpGTToLT<CmpGTI64UOp, CmpLTI64UOp>>(context);
 }
 
+template <typename T>
+static OpFoldResult foldCmpGTFOp(T op, ArrayRef<Attribute> operands) {
+  if (op.lhs() == op.rhs()) {
+    // x > x = false
+    return zeroOfType(op.getType());
+  }
+  return constFoldBinaryOp<FloatAttr>(
+      operands, [&](const APFloat &a, const APFloat &b) {
+        return a.compare(b) == APFloat::cmpGreaterThan;
+      });
+}
+
+OpFoldResult CmpGTF32Op::fold(ArrayRef<Attribute> operands) {
+  return foldCmpGTFOp(*this, operands);
+}
+
+OpFoldResult CmpGTF64Op::fold(ArrayRef<Attribute> operands) {
+  return foldCmpGTFOp(*this, operands);
+}
+
+void CmpGTF32Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                             MLIRContext *context) {
+  results.insert<SwapInvertedCmpOps<CmpGTF32Op, CmpLTEF32Op>>(context);
+  results.insert<RewritePseudoCmpGTToLT<CmpGTF32Op, CmpLTF32Op>>(context);
+}
+
+void CmpGTF64Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                             MLIRContext *context) {
+  results.insert<SwapInvertedCmpOps<CmpGTF64Op, CmpLTEF64Op>>(context);
+  results.insert<RewritePseudoCmpGTToLT<CmpGTF64Op, CmpLTF64Op>>(context);
+}
+
 namespace {
 
 /// Rewrites a vm.cmp.gte.* pseudo op to a vm.cmp.lt.* op.
@@ -1349,6 +1831,39 @@
 }
 
 template <typename T>
+static OpFoldResult foldCmpGTEFOp(T op, ArrayRef<Attribute> operands) {
+  if (op.lhs() == op.rhs()) {
+    // x >= x = true
+    return oneOfType(op.getType());
+  }
+  return constFoldBinaryOp<FloatAttr>(
+      operands, [&](const APFloat &a, const APFloat &b) {
+        return a.compare(b) == APFloat::cmpGreaterThan ||
+               a.compare(b) == APFloat::cmpEqual;
+      });
+}
+
+OpFoldResult CmpGTEF32Op::fold(ArrayRef<Attribute> operands) {
+  return foldCmpGTEFOp(*this, operands);
+}
+
+OpFoldResult CmpGTEF64Op::fold(ArrayRef<Attribute> operands) {
+  return foldCmpGTESOp(*this, operands);
+}
+
+void CmpGTEF32Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                              MLIRContext *context) {
+  results.insert<SwapInvertedCmpOps<CmpGTEF32Op, CmpLTF32Op>>(context);
+  results.insert<RewritePseudoCmpGTEToLT<CmpGTEF32Op, CmpLTF32Op>>(context);
+}
+
+void CmpGTEF64Op::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                              MLIRContext *context) {
+  results.insert<SwapInvertedCmpOps<CmpGTEF64Op, CmpLTF64Op>>(context);
+  results.insert<RewritePseudoCmpGTEToLT<CmpGTEF64Op, CmpLTF64Op>>(context);
+}
+
+template <typename T>
 static OpFoldResult foldCmpGTEUOp(T op, ArrayRef<Attribute> operands) {
   if (op.lhs() == op.rhs()) {
     // x >= x = true
@@ -1388,6 +1903,16 @@
       operands, [&](const APInt &a) { return APInt(64, a.getBoolValue()); });
 }
 
+OpFoldResult CmpNZF32Op::fold(ArrayRef<Attribute> operands) {
+  return constFoldCmpOp<FloatAttr>(
+      operands, [&](const APFloat &a) { return APInt(32, a.isNonZero()); });
+}
+
+OpFoldResult CmpNZF64Op::fold(ArrayRef<Attribute> operands) {
+  return constFoldCmpOp<FloatAttr>(
+      operands, [&](const APFloat &a) { return APInt(32, a.isNonZero()); });
+}
+
 OpFoldResult CmpEQRefOp::fold(ArrayRef<Attribute> operands) {
   if (lhs() == rhs()) {
     // x == x = true
@@ -1768,7 +2293,7 @@
 
 /// Rewrites a check op to a cmp and a cond_fail.
 template <typename CheckOp, typename CmpI32Op, typename CmpI64Op,
-          typename CmpRefOp>
+          typename CmpF32Op, typename CmpF64Op, typename CmpRefOp>
 struct RewriteCheckToCondFail : public OpRewritePattern<CheckOp> {
   using OpRewritePattern<CheckOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(CheckOp op,
@@ -1780,12 +2305,20 @@
       condValue = rewriter.template createOrFold<CmpRefOp>(
           op.getLoc(), ArrayRef<Type>{condType},
           op.getOperation()->getOperands());
+    } else if (operandType.isInteger(32)) {
+      condValue = rewriter.template createOrFold<CmpI32Op>(
+          op.getLoc(), ArrayRef<Type>{condType},
+          op.getOperation()->getOperands());
     } else if (operandType.isInteger(64)) {
       condValue = rewriter.template createOrFold<CmpI64Op>(
           op.getLoc(), ArrayRef<Type>{condType},
           op.getOperation()->getOperands());
-    } else if (operandType.isInteger(32)) {
-      condValue = rewriter.template createOrFold<CmpI32Op>(
+    } else if (operandType.isF32()) {
+      condValue = rewriter.template createOrFold<CmpF32Op>(
+          op.getLoc(), ArrayRef<Type>{condType},
+          op.getOperation()->getOperands());
+    } else if (operandType.isF64()) {
+      condValue = rewriter.template createOrFold<CmpF64Op>(
           op.getLoc(), ArrayRef<Type>{condType},
           op.getOperation()->getOperands());
     } else {
@@ -1806,22 +2339,22 @@
 
 void CheckEQOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                             MLIRContext *context) {
-  results.insert<
-      RewriteCheckToCondFail<CheckEQOp, CmpEQI32Op, CmpEQI64Op, CmpEQRefOp>>(
+  results.insert<RewriteCheckToCondFail<CheckEQOp, CmpEQI32Op, CmpEQI64Op,
+                                        CmpEQF32Op, CmpEQF64Op, CmpEQRefOp>>(
       context);
 }
 
 void CheckNEOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                             MLIRContext *context) {
-  results.insert<
-      RewriteCheckToCondFail<CheckNEOp, CmpNEI32Op, CmpNEI64Op, CmpNERefOp>>(
+  results.insert<RewriteCheckToCondFail<CheckNEOp, CmpNEI32Op, CmpNEI64Op,
+                                        CmpNEF32Op, CmpNEF64Op, CmpNERefOp>>(
       context);
 }
 
 void CheckNZOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                             MLIRContext *context) {
-  results.insert<
-      RewriteCheckToCondFail<CheckNZOp, CmpNZI32Op, CmpNZI64Op, CmpNZRefOp>>(
+  results.insert<RewriteCheckToCondFail<CheckNZOp, CmpNZI32Op, CmpNZI64Op,
+                                        CmpNZF32Op, CmpNZF64Op, CmpNZRefOp>>(
       context);
 }
 
diff --git a/iree/compiler/Dialect/VM/IR/VMOpcodesF32.td b/iree/compiler/Dialect/VM/IR/VMOpcodesF32.td
new file mode 100644
index 0000000..f58dd2d
--- /dev/null
+++ b/iree/compiler/Dialect/VM/IR/VMOpcodesF32.td
@@ -0,0 +1,82 @@
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef IREE_DIALECT_VM_OPCODES_F32
+#define IREE_DIALECT_VM_OPCODES_F32
+
+include "iree/compiler/Dialect/VM/IR/VMBase.td"
+include "iree/compiler/Dialect/VM/IR/VMOpcodesCore.td"
+
+//===----------------------------------------------------------------------===//
+// F32 VM Opcode Extension
+//===----------------------------------------------------------------------===//
+// Ops are encoded as a VM_OPC_ExtF32 + the opcode below.
+
+def VM_OPC_GlobalLoadF32         : VM_OPC<0x00, "GlobalLoadF32">;
+def VM_OPC_GlobalStoreF32        : VM_OPC<0x01, "GlobalStoreF32">;
+def VM_OPC_GlobalLoadIndirectF32 : VM_OPC<0x02, "GlobalLoadIndirectF32">;
+def VM_OPC_GlobalStoreIndirectF32: VM_OPC<0x03, "GlobalStoreIndirectF32">;
+def VM_OPC_ConstF32Zero          : VM_OPC<0x08, "ConstF32Zero">;
+def VM_OPC_ConstF32              : VM_OPC<0x09, "ConstF32">;
+def VM_OPC_ListGetF32            : VM_OPC<0x14, "ListGetF32">;
+def VM_OPC_ListSetF32            : VM_OPC<0x15, "ListSetF32">;
+def VM_OPC_SelectF32             : VM_OPC<0x1E, "SelectF32">;
+def VM_OPC_SwitchF32             : VM_OPC<0x20, "SwitchF32">;
+def VM_OPC_AddF32                : VM_OPC<0x22, "AddF32">;
+def VM_OPC_SubF32                : VM_OPC<0x23, "SubF32">;
+def VM_OPC_MulF32                : VM_OPC<0x24, "MulF32">;
+def VM_OPC_DivF32                : VM_OPC<0x25, "DivF32">;
+def VM_OPC_RemF32                : VM_OPC<0x27, "RemF32">;
+def VM_OPC_AbsF32                : VM_OPC<0x2D, "AbsF32">;
+def VM_OPC_NegF32                : VM_OPC<0x2E, "NegF32">;
+def VM_OPC_CeilF32               : VM_OPC<0x2F, "CeilF32">;
+def VM_OPC_FloorF32              : VM_OPC<0x32, "FloorF32">;
+def VM_OPC_CmpEQF32              : VM_OPC<0x40, "CmpEQF32">;
+def VM_OPC_CmpNEF32              : VM_OPC<0x41, "CmpNEF32">;
+def VM_OPC_CmpNZF32              : VM_OPC<0x42, "CmpNZF32">;
+def VM_OPC_CmpLTF32              : VM_OPC<0x43, "CmpLTF32">;
+
+// Runtime enum iree_vm_ext_f32_op_t:
+def VM_ExtF32OpcodeAttr :
+    VM_OPC_EnumAttr<"ExtF32Opcode",
+                    "iree_vm_ext_f32_op_t",
+                    "EXT_F32",  // IREE_VM_OP_EXT_F32_*
+                    "valid VM operation encodings in the f32 extension",
+                    VM_OPC_PrefixExtF32, [
+    VM_OPC_GlobalLoadF32,
+    VM_OPC_GlobalStoreF32,
+    VM_OPC_GlobalLoadIndirectF32,
+    VM_OPC_GlobalStoreIndirectF32,
+    VM_OPC_ConstF32Zero,
+    VM_OPC_ConstF32,
+    VM_OPC_ListGetF32,
+    VM_OPC_ListSetF32,
+    VM_OPC_SelectF32,
+    VM_OPC_SwitchF32,
+    VM_OPC_AddF32,
+    VM_OPC_SubF32,
+    VM_OPC_MulF32,
+    VM_OPC_DivF32,
+    VM_OPC_RemF32,
+    VM_OPC_AbsF32,
+    VM_OPC_NegF32,
+    VM_OPC_CeilF32,
+    VM_OPC_FloorF32,
+    VM_OPC_CmpEQF32,
+    VM_OPC_CmpNEF32,
+    VM_OPC_CmpNZF32,
+    VM_OPC_CmpLTF32,
+  ]>;
+
+#endif  // IREE_DIALECT_VM_OPCODES_F32
diff --git a/iree/compiler/Dialect/VM/IR/VMOpcodesF64.td b/iree/compiler/Dialect/VM/IR/VMOpcodesF64.td
new file mode 100644
index 0000000..7c4501e
--- /dev/null
+++ b/iree/compiler/Dialect/VM/IR/VMOpcodesF64.td
@@ -0,0 +1,86 @@
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef IREE_DIALECT_VM_OPCODES_F64
+#define IREE_DIALECT_VM_OPCODES_F64
+
+include "iree/compiler/Dialect/VM/IR/VMBase.td"
+include "iree/compiler/Dialect/VM/IR/VMOpcodesCore.td"
+
+//===----------------------------------------------------------------------===//
+// F64 VM Opcode Extension
+//===----------------------------------------------------------------------===//
+// Ops are encoded as a VM_OPC_ExtF64 + the opcode below.
+
+def VM_OPC_GlobalLoadF64         : VM_OPC<0x00, "GlobalLoadF64">;
+def VM_OPC_GlobalStoreF64        : VM_OPC<0x01, "GlobalStoreF64">;
+def VM_OPC_GlobalLoadIndirectF64 : VM_OPC<0x02, "GlobalLoadIndirectF64">;
+def VM_OPC_GlobalStoreIndirectF64: VM_OPC<0x03, "GlobalStoreIndirectF64">;
+def VM_OPC_ConstF64Zero          : VM_OPC<0x08, "ConstF64Zero">;
+def VM_OPC_ConstF64              : VM_OPC<0x09, "ConstF64">;
+def VM_OPC_ListGetF64            : VM_OPC<0x14, "ListGetF64">;
+def VM_OPC_ListSetF64            : VM_OPC<0x15, "ListSetF64">;
+def VM_OPC_SelectF64             : VM_OPC<0x1E, "SelectF64">;
+def VM_OPC_SwitchF64             : VM_OPC<0x20, "SwitchF64">;
+def VM_OPC_AddF64                : VM_OPC<0x22, "AddF64">;
+def VM_OPC_SubF64                : VM_OPC<0x23, "SubF64">;
+def VM_OPC_MulF64                : VM_OPC<0x24, "MulF64">;
+def VM_OPC_DivF64                : VM_OPC<0x25, "DivF64">;
+def VM_OPC_RemF64                : VM_OPC<0x27, "RemF64">;
+def VM_OPC_AbsF64                : VM_OPC<0x2D, "AbsF64">;
+def VM_OPC_NegF64                : VM_OPC<0x2E, "NegF64">;
+def VM_OPC_CeilF64               : VM_OPC<0x2F, "CeilF64">;
+def VM_OPC_FloorF64              : VM_OPC<0x31, "FloorF64">;
+def VM_OPC_TruncF64F32           : VM_OPC<0x32, "TruncF64F32">;
+def VM_OPC_ExtF32F64             : VM_OPC<0x37, "ExtF32F64">;
+def VM_OPC_CmpEQF64              : VM_OPC<0x40, "CmpEQF64">;
+def VM_OPC_CmpNEF64              : VM_OPC<0x41, "CmpNEF64">;
+def VM_OPC_CmpNZF64              : VM_OPC<0x42, "CmpNZF64">;
+def VM_OPC_CmpLTF64              : VM_OPC<0x43, "CmpLTF64">;
+
+// Runtime enum iree_vm_ext_f64_op_t:
+def VM_ExtF64OpcodeAttr :
+    VM_OPC_EnumAttr<"ExtF64Opcode",
+                    "iree_vm_ext_f64_op_t",
+                    "EXT_F64",  // IREE_VM_OP_EXT_F64_*
+                    "valid VM operation encodings in the f64 extension",
+                    VM_OPC_PrefixExtF64, [
+    VM_OPC_GlobalLoadF64,
+    VM_OPC_GlobalStoreF64,
+    VM_OPC_GlobalLoadIndirectF64,
+    VM_OPC_GlobalStoreIndirectF64,
+    VM_OPC_ConstF64Zero,
+    VM_OPC_ConstF64,
+    VM_OPC_ListGetF64,
+    VM_OPC_ListSetF64,
+    VM_OPC_SelectF64,
+    VM_OPC_SwitchF64,
+    VM_OPC_AddF64,
+    VM_OPC_SubF64,
+    VM_OPC_MulF64,
+    VM_OPC_DivF64,
+    VM_OPC_RemF64,
+    VM_OPC_AbsF64,
+    VM_OPC_NegF64,
+    VM_OPC_CeilF64,
+    VM_OPC_FloorF64,
+    VM_OPC_TruncF64F32,
+    VM_OPC_ExtF32F64,
+    VM_OPC_CmpEQF64,
+    VM_OPC_CmpNEF64,
+    VM_OPC_CmpNZF64,
+    VM_OPC_CmpLTF64,
+  ]>;
+
+#endif  // IREE_DIALECT_VM_OPCODES_F64
diff --git a/iree/compiler/Dialect/VM/IR/VMOps.cpp b/iree/compiler/Dialect/VM/IR/VMOps.cpp
index 765330c..896ba5f 100644
--- a/iree/compiler/Dialect/VM/IR/VMOps.cpp
+++ b/iree/compiler/Dialect/VM/IR/VMOps.cpp
@@ -451,6 +451,16 @@
   addMemoryEffectsForGlobal<GlobalI64Op>(*this, global(), effects);
 }
 
+void GlobalLoadF32Op::getEffects(
+    SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
+  addMemoryEffectsForGlobal<GlobalF32Op>(*this, global(), effects);
+}
+
+void GlobalLoadF64Op::getEffects(
+    SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
+  addMemoryEffectsForGlobal<GlobalF64Op>(*this, global(), effects);
+}
+
 void GlobalLoadRefOp::getEffects(
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   addMemoryEffectsForGlobal<GlobalRefOp>(*this, global(), effects);
@@ -499,8 +509,7 @@
 //===----------------------------------------------------------------------===//
 
 template <typename T>
-static ParseResult parseConstIntegerOp(OpAsmParser &parser,
-                                       OperationState *result) {
+static ParseResult parseConstOp(OpAsmParser &parser, OperationState *result) {
   Attribute valueAttr;
   NamedAttrList dummyAttrs;
   if (failed(parser.parseAttribute(valueAttr, "value", dummyAttrs))) {
@@ -521,7 +530,7 @@
 }
 
 template <typename T>
-static void printConstIntegerOp(OpAsmPrinter &p, T &op) {
+static void printConstOp(OpAsmPrinter &p, T &op) {
   p << op.getOperationName() << ' ';
   p.printAttribute(op.value());
   p.printOptionalAttrDict(op->getAttrs(), /*elidedAttrs=*/{"value"});
@@ -548,6 +557,26 @@
 }
 
 template <int SZ>
+static bool isConstFloatBuildableWith(Attribute value, Type type) {
+  // FlatSymbolRefAttr can only be used with a function type.
+  if (value.isa<FlatSymbolRefAttr>()) {
+    return false;
+  }
+  // Otherwise, the attribute must have the same type as 'type'.
+  if (value.getType() != type) {
+    return false;
+  }
+  Type elementType;
+  if (auto floatAttr = value.dyn_cast<FloatAttr>()) {
+    elementType = floatAttr.getType();
+  } else if (auto elementsAttr = value.dyn_cast<ElementsAttr>()) {
+    elementType = elementsAttr.getType().getElementType();
+  }
+  if (!elementType) return false;
+  return elementType.getIntOrFloatBitWidth() == SZ;
+}
+
+template <int SZ>
 static Attribute convertConstIntegerValue(Attribute value) {
   assert(isConstIntegerBuildableWith<SZ>(value, value.getType()));
   Builder builder(value.getContext());
@@ -574,6 +603,42 @@
   return Attribute();
 }
 
+static FloatType getFloatType(int bitwidth, MLIRContext *context) {
+  switch (bitwidth) {
+    case 16:
+      return FloatType::getF16(context);
+    case 32:
+      return FloatType::getF32(context);
+    case 64:
+      return FloatType::getF64(context);
+    default:
+      llvm_unreachable("unhandled floating point type");
+      return {};
+  }
+}
+
+template <int SZ>
+static Attribute convertConstFloatValue(Attribute value) {
+  assert(isConstFloatBuildableWith<SZ>(value, value.getType()));
+  Builder builder(value.getContext());
+  auto floatType = getFloatType(SZ, value.getContext());
+  int32_t dims = 1;
+  if (auto v = value.dyn_cast<FloatAttr>()) {
+    return FloatAttr::get(floatType, v.getValue());
+  } else if (auto v = value.dyn_cast<ElementsAttr>()) {
+    dims = v.getNumElements();
+    ShapedType adjustedType = VectorType::get({dims}, floatType);
+    if (auto elements = v.dyn_cast<SplatElementsAttr>()) {
+      return SplatElementsAttr::get(adjustedType, elements.getSplatValue());
+    } else {
+      return DenseElementsAttr::get(
+          adjustedType, llvm::to_vector<4>(v.getValues<Attribute>()));
+    }
+  }
+  llvm_unreachable("unexpected attribute type");
+  return Attribute();
+}
+
 // static
 bool ConstI32Op::isBuildableWith(Attribute value, Type type) {
   return isConstIntegerBuildableWith<32>(value, type);
@@ -618,6 +683,50 @@
   return build(builder, result, builder.getI64IntegerAttr(value));
 }
 
+// static
+bool ConstF32Op::isBuildableWith(Attribute value, Type type) {
+  return isConstFloatBuildableWith<32>(value, type);
+}
+
+// static
+Attribute ConstF32Op::convertConstValue(Attribute value) {
+  return convertConstFloatValue<32>(value);
+}
+
+void ConstF32Op::build(OpBuilder &builder, OperationState &result,
+                       Attribute value) {
+  Attribute newValue = convertConstValue(value);
+  result.addAttribute("value", newValue);
+  result.addTypes(newValue.getType());
+}
+
+void ConstF32Op::build(OpBuilder &builder, OperationState &result,
+                       float value) {
+  return build(builder, result, builder.getF32FloatAttr(value));
+}
+
+// static
+bool ConstF64Op::isBuildableWith(Attribute value, Type type) {
+  return isConstFloatBuildableWith<64>(value, type);
+}
+
+// static
+Attribute ConstF64Op::convertConstValue(Attribute value) {
+  return convertConstFloatValue<64>(value);
+}
+
+void ConstF64Op::build(OpBuilder &builder, OperationState &result,
+                       Attribute value) {
+  Attribute newValue = convertConstValue(value);
+  result.addAttribute("value", newValue);
+  result.addTypes(newValue.getType());
+}
+
+void ConstF64Op::build(OpBuilder &builder, OperationState &result,
+                       double value) {
+  return build(builder, result, builder.getF64FloatAttr(value));
+}
+
 void ConstI32ZeroOp::build(OpBuilder &builder, OperationState &result) {
   result.addTypes(builder.getIntegerType(32));
 }
@@ -626,6 +735,14 @@
   result.addTypes(builder.getIntegerType(64));
 }
 
+void ConstF32ZeroOp::build(OpBuilder &builder, OperationState &result) {
+  result.addTypes(builder.getF32Type());
+}
+
+void ConstF64ZeroOp::build(OpBuilder &builder, OperationState &result) {
+  result.addTypes(builder.getF64Type());
+}
+
 void ConstRefZeroOp::build(OpBuilder &builder, OperationState &result,
                            Type objectType) {
   result.addTypes(objectType);
diff --git a/iree/compiler/Dialect/VM/IR/VMOps.td b/iree/compiler/Dialect/VM/IR/VMOps.td
index 0107f92..04e93bc 100644
--- a/iree/compiler/Dialect/VM/IR/VMOps.td
+++ b/iree/compiler/Dialect/VM/IR/VMOps.td
@@ -275,7 +275,8 @@
         $_state.addAttribute("initializer",
                             $_builder.getSymbolRefAttr(initializer.getValue()));
       } else if (initialValue.hasValue() &&
-                 initialValue.getValue().isa<IntegerAttr>()) {
+                 (initialValue.getValue().isa<IntegerAttr>() ||
+                  initialValue.getValue().isa<FloatAttr>())) {
         $_state.addAttribute("initial_value", initialValue.getValue());
       }
       $_state.addAttribute("type", TypeAttr::get(type));
@@ -343,6 +344,30 @@
   let hasCanonicalizer = 1;
 }
 
+def VM_GlobalF32Op : VM_GlobalOp<"global.f32",
+                                 VM_ConstantFloatValueAttr<F32>,
+                                 [VM_ExtF32]> {
+  let summary = [{32-bit floating-point global declaration}];
+  let description = [{
+    Defines a global value that is treated as a scalar literal at runtime.
+    Initialized to zero unless a custom initializer function is specified.
+  }];
+
+  let hasCanonicalizer = 1;
+}
+
+def VM_GlobalF64Op : VM_GlobalOp<"global.f64",
+                                 VM_ConstantFloatValueAttr<F64>,
+                                 [VM_ExtF64]> {
+  let summary = [{64-bit floating-point global declaration}];
+  let description = [{
+    Defines a global value that is treated as a scalar literal at runtime.
+    Initialized to zero unless a custom initializer function is specified.
+  }];
+
+  let hasCanonicalizer = 1;
+}
+
 def VM_GlobalRefOp : VM_GlobalOp<"global.ref", UnitAttr> {
   let summary = [{ref<T> global declaration}];
   let description = [{
@@ -505,6 +530,20 @@
   let hasCanonicalizer = 1;
 }
 
+def VM_GlobalLoadF32Op :
+    VM_GlobalLoadPrimitiveOp<F32, "global.load.f32", VM_OPC_GlobalLoadF32,
+                             [VM_ExtF32]> {
+  let summary = [{global 32-bit floating-point load operation}];
+  let hasCanonicalizer = 1;
+}
+
+def VM_GlobalLoadF64Op :
+    VM_GlobalLoadPrimitiveOp<F64, "global.load.f64", VM_OPC_GlobalLoadF64,
+                             [VM_ExtF64]> {
+  let summary = [{global 64-bit floating-point load operation}];
+  let hasCanonicalizer = 1;
+}
+
 def VM_GlobalStoreI32Op :
     VM_GlobalStorePrimitiveOp<I32, "global.store.i32", VM_OPC_GlobalStoreI32> {
   let summary = [{global 32-bit integer store operation}];
@@ -516,6 +555,18 @@
   let summary = [{global 64-bit integer store operation}];
 }
 
+def VM_GlobalStoreF32Op :
+    VM_GlobalStorePrimitiveOp<F32, "global.store.f32", VM_OPC_GlobalStoreF32,
+                              [VM_ExtF32]> {
+  let summary = [{global 32-bit floating-point store operation}];
+}
+
+def VM_GlobalStoreF64Op :
+    VM_GlobalStorePrimitiveOp<F64, "global.store.f64", VM_OPC_GlobalStoreF64,
+                              [VM_ExtF64]> {
+  let summary = [{global 64-bit floating-point store operation}];
+}
+
 def VM_GlobalLoadIndirectI32Op :
     VM_GlobalLoadIndirectPrimitiveOp<I32, "global.load.indirect.i32",
                                      VM_OPC_GlobalLoadIndirectI32> {
@@ -531,6 +582,22 @@
   let hasCanonicalizer = 1;
 }
 
+def VM_GlobalLoadIndirectF32Op :
+    VM_GlobalLoadIndirectPrimitiveOp<F32, "global.load.indirect.f32",
+                                     VM_OPC_GlobalLoadIndirectF32,
+                                     [VM_ExtF64]> {
+  let summary = [{global 32-bit floating-point load operation}];
+  let hasCanonicalizer = 1;
+}
+
+def VM_GlobalLoadIndirectF64Op :
+    VM_GlobalLoadIndirectPrimitiveOp<F64, "global.load.indirect.f64",
+                                     VM_OPC_GlobalLoadIndirectF64,
+                                     [VM_ExtI64]> {
+  let summary = [{global 64-bit floating-point load operation}];
+  let hasCanonicalizer = 1;
+}
+
 def VM_GlobalStoreIndirectI32Op :
     VM_GlobalStoreIndirectPrimitiveOp<I32, "global.store.indirect.i32",
                                       VM_OPC_GlobalStoreIndirectI32> {
@@ -546,6 +613,22 @@
   let hasCanonicalizer = 1;
 }
 
+def VM_GlobalStoreIndirectF32Op :
+    VM_GlobalStoreIndirectPrimitiveOp<F32, "global.store.indirect.f32",
+                                      VM_OPC_GlobalStoreIndirectI32,
+                                      [VM_ExtF32]> {
+  let summary = [{global 32-bit floating-point store operation}];
+  let hasCanonicalizer = 1;
+}
+
+def VM_GlobalStoreIndirectF64Op :
+    VM_GlobalStoreIndirectPrimitiveOp<F64, "global.store.indirect.f64",
+                                      VM_OPC_GlobalStoreIndirectF64,
+                                      [VM_ExtF64]> {
+  let summary = [{global 64-bit floating-point store operation}];
+  let hasCanonicalizer = 1;
+}
+
 def VM_GlobalLoadRefOp : VM_GlobalLoadOp<VM_AnyRef, "global.load.ref"> {
   let summary = [{global ref<T> load operation}];
   let description = [{
@@ -653,8 +736,8 @@
     VM_EncResult<"result">,
   ];
 
-  let parser = [{ return parseConstIntegerOp<$cppClass>(parser, &result); }];
-  let printer = [{ return printConstIntegerOp<$cppClass>(p, *this); }];
+  let parser = [{ return parseConstOp<$cppClass>(parser, &result); }];
+  let printer = [{ return printConstOp<$cppClass>(p, *this); }];
 }
 
 def VM_ConstI32Op :
@@ -679,6 +762,28 @@
   let hasCanonicalizer = 1;
 }
 
+def VM_ConstF32Op :
+    VM_ConstantPrimitiveOp<F32, 32, "const.f32", VM_OPC_ConstF32,
+                           "float", [VM_ExtF32]> {
+  let summary = [{32-bit floating-point constant operation}];
+  let arguments = (ins
+    VM_ConstantFloatValueAttr<F32>:$value
+  );
+  let hasFolder = 1;
+  let hasCanonicalizer = 1;
+}
+
+def VM_ConstF64Op :
+    VM_ConstantPrimitiveOp<F64, 64, "const.f64", VM_OPC_ConstF64,
+                           "double", [VM_ExtF64]> {
+  let summary = [{64-bit floating-point constant operation}];
+  let arguments = (ins
+    VM_ConstantFloatValueAttr<F64>:$value
+  );
+  let hasFolder = 1;
+  let hasCanonicalizer = 1;
+}
+
 class VM_ConstantPrimitiveZeroOp<Type type, string mnemonic, VM_OPC opcode,
                                  string ctype, list<OpTrait> traits = []> :
     VM_ConstOp<mnemonic, ctype, traits> {
@@ -717,6 +822,20 @@
   let hasFolder = 1;
 }
 
+def VM_ConstF32ZeroOp :
+    VM_ConstantPrimitiveZeroOp<F32, "const.f32.zero", VM_OPC_ConstF32Zero,
+                               "float", [VM_ExtF32]> {
+  let summary = [{32-bit floating-point constant zero operation}];
+  let hasFolder = 1;
+}
+
+def VM_ConstF64ZeroOp :
+    VM_ConstantPrimitiveZeroOp<F64, "const.f64.zero", VM_OPC_ConstF64Zero,
+                               "double", [VM_ExtI64]> {
+  let summary = [{64-bit floating-point constant zero operation}];
+  let hasFolder = 1;
+}
+
 def VM_ConstRefZeroOp : VM_PureOp<"const.ref.zero", [
     ConstantLike,
     DeclareOpInterfaceMethods<VM_SerializableOpInterface>,
@@ -1024,12 +1143,24 @@
 def VM_ListGetI64Op :
     VM_ListGetPrimitiveOp<I64, "list.get.i64", VM_OPC_ListGetI64, [VM_ExtI64]>;
 
+def VM_ListGetF32Op :
+    VM_ListGetPrimitiveOp<F32, "list.get.f32", VM_OPC_ListGetF32, [VM_ExtF32]>;
+
+def VM_ListGetF64Op :
+    VM_ListGetPrimitiveOp<F64, "list.get.f64", VM_OPC_ListGetF64, [VM_ExtF64]>;
+
 def VM_ListSetI32Op :
     VM_ListSetPrimitiveOp<I32, "list.set.i32", VM_OPC_ListSetI32>;
 
 def VM_ListSetI64Op :
     VM_ListSetPrimitiveOp<I64, "list.set.i64", VM_OPC_ListSetI64, [VM_ExtI64]>;
 
+def VM_ListSetF32Op :
+    VM_ListSetPrimitiveOp<F32, "list.set.f32", VM_OPC_ListSetF32, [VM_ExtF32]>;
+
+def VM_ListSetF64Op :
+    VM_ListSetPrimitiveOp<F64, "list.set.f64", VM_OPC_ListSetF64, [VM_ExtF64]>;
+
 def VM_ListGetRefOp :
     VM_PureOp<"list.get.ref", [
       DeclareOpInterfaceMethods<VM_SerializableOpInterface>,
@@ -1144,6 +1275,18 @@
   let hasFolder = 1;
 }
 
+def VM_SelectF32Op : VM_SelectPrimitiveOp<F32, "select.f32", VM_OPC_SelectF32,
+                                          [VM_ExtF32]> {
+  let summary = [{floating-point select operation}];
+  let hasFolder = 1;
+}
+
+def VM_SelectF64Op : VM_SelectPrimitiveOp<F64, "select.f64", VM_OPC_SelectF64,
+                                          [VM_ExtF64]> {
+  let summary = [{floating-point select operation}];
+  let hasFolder = 1;
+}
+
 def VM_SelectRefOp : VM_PureOp<"select.ref", [
     DeclareOpInterfaceMethods<VM_SerializableOpInterface>,
     AllTypesMatch<["true_value", "false_value", "result"]>,
@@ -1189,8 +1332,8 @@
     the index is out of bounds.
 
     ```mlir
-    // Switch %arg0 to cases of %c100/%c200/%c300 if arg0==0, ==1, ==2.
-    // If %arg0 is out of range (<0 or >2) then default to %c5.
+    // Switch %index to cases of %c100/%c200/%c300 if index==0, ==1, ==2.
+    // If %index is out of range (<0 or >2) then default to %c5.
     %0 = vm.switch.i32 %index[%c100, %c200, %c300] else %c5 : i32
     ```
   }];
@@ -1267,6 +1410,18 @@
   let hasFolder = 1;
 }
 
+def VM_SwitchF32Op : VM_SwitchFloatOp<F32, "switch.f32", VM_OPC_SwitchF32,
+                                      [VM_ExtF32]> {
+  let summary = [{floating-point switch operation}];
+  let hasFolder = 1;
+}
+
+def VM_SwitchF64Op : VM_SwitchFloatOp<F64, "switch.f64", VM_OPC_SwitchF64,
+                                      [VM_ExtF64]> {
+  let summary = [{floating-point switch operation}];
+  let hasFolder = 1;
+}
+
 def VM_SwitchRefOp : VM_PureOp<"switch.ref", [
     DeclareOpInterfaceMethods<VM_SerializableOpInterface>,
     AllTypesMatch<["default_value", "result"]>,
@@ -1478,6 +1633,138 @@
 }
 
 //===----------------------------------------------------------------------===//
+// Floating-point arithmetic
+//===----------------------------------------------------------------------===//
+
+def VM_AddF32Op :
+    VM_BinaryArithmeticOp<F32, "add.f32", VM_OPC_AddF32,
+                          [VM_ExtF32, Commutative]> {
+  let summary = [{floating-point add operation}];
+  let hasFolder = 1;
+}
+
+def VM_AddF64Op :
+    VM_BinaryArithmeticOp<F64, "add.f64", VM_OPC_AddF64,
+                          [VM_ExtF64, Commutative]> {
+  let summary = [{floating-point add operation}];
+  let hasFolder = 1;
+}
+
+def VM_SubF32Op :
+    VM_BinaryArithmeticOp<F32, "sub.f32", VM_OPC_SubF32,
+                          [VM_ExtF32]> {
+  let summary = [{floating point subtraction operation}];
+  let hasFolder = 1;
+}
+
+def VM_SubF64Op :
+    VM_BinaryArithmeticOp<F64, "sub.f64", VM_OPC_SubF64,
+                          [VM_ExtF64]> {
+  let summary = [{floating point subtraction operation}];
+  let hasFolder = 1;
+}
+
+def VM_MulF32Op :
+    VM_BinaryArithmeticOp<F32, "mul.f32", VM_OPC_MulF32,
+                          [VM_ExtF32, Commutative]> {
+  let summary = [{floating point multiplication operation}];
+  let hasFolder = 1;
+  let hasCanonicalizer = 1;
+}
+
+def VM_MulF64Op :
+    VM_BinaryArithmeticOp<F64, "mul.f64", VM_OPC_MulF64,
+                          [VM_ExtF64, Commutative]> {
+  let summary = [{floating point multiplication operation}];
+  let hasFolder = 1;
+  let hasCanonicalizer = 1;
+}
+
+def VM_DivF32Op :
+    VM_BinaryArithmeticOp<F32, "div.f32", VM_OPC_DivF32,
+                          [VM_ExtF32]> {
+  let summary = [{floating point division operation}];
+  let hasFolder = 1;
+}
+
+def VM_DivF64Op :
+    VM_BinaryArithmeticOp<F64, "div.f64", VM_OPC_DivF64,
+                          [VM_ExtF64]> {
+  let summary = [{floating point division operation}];
+  let hasFolder = 1;
+}
+
+def VM_RemF32Op :
+    VM_BinaryArithmeticOp<F32, "rem.f32", VM_OPC_RemF32,
+                          [VM_ExtF32]> {
+  let summary = [{floating point remainder operation}];
+  let hasFolder = 1;
+}
+
+def VM_RemF64Op :
+    VM_BinaryArithmeticOp<F64, "rem.f64", VM_OPC_RemF64,
+                          [VM_ExtF64]> {
+  let summary = [{floating point remainder operation}];
+  let hasFolder = 1;
+}
+
+def VM_AbsF32Op :
+    VM_UnaryArithmeticOp<F32, "abs.f32", VM_OPC_AbsF32,
+                         [VM_ExtF32]> {
+  let summary = [{floating point absolute-value operation}];
+  let hasFolder = 1;
+}
+
+def VM_AbsF64Op :
+    VM_UnaryArithmeticOp<F64, "abs.f64", VM_OPC_AbsF64,
+                         [VM_ExtF64]> {
+  let summary = [{floating point absolute-value operation}];
+  let hasFolder = 1;
+}
+
+def VM_NegF32Op :
+    VM_UnaryArithmeticOp<F32, "neg.f32", VM_OPC_NegF32,
+                         [VM_ExtF32]> {
+  let summary = [{floating point negation operation}];
+  let hasFolder = 1;
+}
+
+def VM_NegF64Op :
+    VM_UnaryArithmeticOp<F64, "neg.f64", VM_OPC_NegF64,
+                         [VM_ExtF64]> {
+  let summary = [{floating point negation operation}];
+  let hasFolder = 1;
+}
+
+def VM_CeilF32Op :
+    VM_UnaryArithmeticOp<F32, "ceil.f32", VM_OPC_CeilF32,
+                         [VM_ExtF32]> {
+  let summary = [{floating point ceiling operation}];
+  let hasFolder = 1;
+}
+
+def VM_CeilF64Op :
+    VM_UnaryArithmeticOp<F64, "ceil.f64", VM_OPC_CeilF64,
+                         [VM_ExtF64]> {
+  let summary = [{floating point ceiling operation}];
+  let hasFolder = 1;
+}
+
+def VM_FloorF32Op :
+    VM_UnaryArithmeticOp<F32, "floor.f32", VM_OPC_FloorF32,
+                         [VM_ExtF32]> {
+  let summary = [{floating point floor operation}];
+  let hasFolder = 1;
+}
+
+def VM_FloorF64Op :
+    VM_UnaryArithmeticOp<F64, "floor.f64", VM_OPC_FloorF64,
+                         [VM_ExtF64]> {
+  let summary = [{floating point floor operation}];
+  let hasFolder = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // Integer bit manipulation
 //===----------------------------------------------------------------------===//
 
@@ -1674,6 +1961,13 @@
   let hasFolder = 1;
 }
 
+def VM_TruncF64F32Op :
+    VM_ConversionOp<F64, F32, "trunc.f64.f32", VM_OPC_TruncF64F32,
+                    [VM_ExtF64]> {
+  let summary = [{floating-point truncate to 32 bits}];
+  let hasFolder = 1;
+}
+
 def VM_ExtI8I32SOp :
     VM_ConversionOp<I32, I32, "ext.i8.i32.s", VM_OPC_ExtI8I32S> {
   let summary = [{integer sign extend 8 bits to 32 bits}];
@@ -1740,6 +2034,13 @@
   let hasFolder = 1;
 }
 
+def VM_ExtF32F64Op :
+    VM_ConversionOp<F32, F64, "ext.f32.f64", VM_OPC_ExtF32F64,
+                    [VM_ExtF64]> {
+  let summary = [{floating-point zero extend 32 bits to 64 bits}];
+  let hasFolder = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // Native reduction (horizontal) arithmetic
 //===----------------------------------------------------------------------===//
@@ -1840,6 +2141,22 @@
   let hasFolder = 1;
 }
 
+def VM_CmpEQF32Op :
+    VM_BinaryComparisonOp<F32, "cmp.eq.f32", VM_OPC_CmpEQF32,
+                          [VM_ExtF32, Commutative]> {
+  let summary = [{floating-point equality comparison operation}];
+  let hasCanonicalizer = 1;
+  let hasFolder = 1;
+}
+
+def VM_CmpEQF64Op :
+    VM_BinaryComparisonOp<F64, "cmp.eq.f64", VM_OPC_CmpEQF64,
+                          [VM_ExtF64, Commutative]> {
+  let summary = [{floating-point equality comparison operation}];
+  let hasCanonicalizer = 1;
+  let hasFolder = 1;
+}
+
 def VM_CmpNEI32Op :
     VM_BinaryComparisonOp<I32, "cmp.ne.i32", VM_OPC_CmpNEI32,
                           [Commutative]> {
@@ -1856,6 +2173,22 @@
   let hasFolder = 1;
 }
 
+def VM_CmpNEF32Op :
+    VM_BinaryComparisonOp<F32, "cmp.ne.f32", VM_OPC_CmpNEF32,
+                          [VM_ExtF32, Commutative]> {
+  let summary = [{floating-point inequality comparison operation}];
+  let hasCanonicalizer = 1;
+  let hasFolder = 1;
+}
+
+def VM_CmpNEF64Op :
+    VM_BinaryComparisonOp<F64, "cmp.ne.f64", VM_OPC_CmpNEF64,
+                          [VM_ExtF64, Commutative]> {
+  let summary = [{floating-point inequality comparison operation}];
+  let hasCanonicalizer = 1;
+  let hasFolder = 1;
+}
+
 def VM_CmpLTI32SOp :
     VM_BinaryComparisonOp<I32, "cmp.lt.i32.s", VM_OPC_CmpLTI32S> {
   let summary = [{signed integer less-than comparison operation}];
@@ -1871,6 +2204,22 @@
   let hasFolder = 1;
 }
 
+def VM_CmpLTF32Op :
+    VM_BinaryComparisonOp<F32, "cmp.lt.f32", VM_OPC_CmpLTF32,
+                          [VM_ExtF32]> {
+  let summary = [{floating-point less-than comparison operation}];
+  let hasCanonicalizer = 1;
+  let hasFolder = 1;
+}
+
+def VM_CmpLTF64Op :
+    VM_BinaryComparisonOp<F64, "cmp.lt.f64", VM_OPC_CmpLTF64,
+                          [VM_ExtF64]> {
+  let summary = [{floating-point less-than comparison operation}];
+  let hasCanonicalizer = 1;
+  let hasFolder = 1;
+}
+
 def VM_CmpLTI32UOp :
     VM_BinaryComparisonOp<I32, "cmp.lt.i32.u", VM_OPC_CmpLTI32U> {
   let summary = [{unsigned integer less-than comparison operation}];
@@ -1916,6 +2265,22 @@
   let hasFolder = 1;
 }
 
+def VM_CmpLTEF32Op :
+    VM_BinaryComparisonPseudoOp<F32, "cmp.lte.f32",
+                                [VM_ExtF32]> {
+  let summary = [{floating-point less-than-or-equal comparison operation}];
+  let hasCanonicalizer = 1;
+  let hasFolder = 1;
+}
+
+def VM_CmpLTEF64Op :
+    VM_BinaryComparisonPseudoOp<F64, "cmp.lte.f64",
+                                [VM_ExtF64]> {
+  let summary = [{floating-point less-than-or-equal comparison operation}];
+  let hasCanonicalizer = 1;
+  let hasFolder = 1;
+}
+
 def VM_CmpGTI32SOp :
     VM_BinaryComparisonPseudoOp<I32, "cmp.gt.i32.s"> {
   let summary = [{signed integer greater-than comparison operation}];
@@ -1946,6 +2311,22 @@
   let hasFolder = 1;
 }
 
+def VM_CmpGTF32Op :
+    VM_BinaryComparisonPseudoOp<F32, "cmp.gt.f32",
+                                [VM_ExtF32]> {
+  let summary = [{floating-point greater-than comparison operation}];
+  let hasCanonicalizer = 1;
+  let hasFolder = 1;
+}
+
+def VM_CmpGTF64Op :
+    VM_BinaryComparisonPseudoOp<F64, "cmp.gt.f64",
+                                [VM_ExtF64]> {
+  let summary = [{floating-point greater-than comparison operation}];
+  let hasCanonicalizer = 1;
+  let hasFolder = 1;
+}
+
 def VM_CmpGTEI32SOp :
     VM_BinaryComparisonPseudoOp<I32, "cmp.gte.i32.s"> {
   let summary = [{signed integer greater-than-or-equal comparison operation}];
@@ -1976,6 +2357,22 @@
   let hasFolder = 1;
 }
 
+def VM_CmpGTEF32Op :
+    VM_BinaryComparisonPseudoOp<F32, "cmp.gte.f32",
+                                [VM_ExtF32]> {
+  let summary = [{floating-point greater-than-or-equal comparison operation}];
+  let hasCanonicalizer = 1;
+  let hasFolder = 1;
+}
+
+def VM_CmpGTEF64Op :
+    VM_BinaryComparisonPseudoOp<F64, "cmp.gte.f64",
+                                [VM_ExtF64]> {
+  let summary = [{floating-point greater-than-or-equal comparison operation}];
+  let hasCanonicalizer = 1;
+  let hasFolder = 1;
+}
+
 def VM_CmpNZI32Op :
     VM_UnaryComparisonOp<I32, "cmp.nz.i32", VM_OPC_CmpNZI32> {
   let summary = [{integer non-zero comparison operation}];
@@ -1995,6 +2392,26 @@
   let hasFolder = 1;
 }
 
+def VM_CmpNZF32Op :
+    VM_UnaryComparisonOp<F32, "cmp.nz.f32", VM_OPC_CmpNZF32,
+                         [VM_ExtF32]> {
+  let summary = [{floating-point non-zero comparison operation}];
+  let description = [{
+    Compares the given floating-point operand for a non-zero value.
+  }];
+  let hasFolder = 1;
+}
+
+def VM_CmpNZF64Op :
+    VM_UnaryComparisonOp<F64, "cmp.nz.f64", VM_OPC_CmpNZF64,
+                         [VM_ExtF64]> {
+  let summary = [{floating-point non-zero comparison operation}];
+  let description = [{
+    Compares the given floating-point operand for a non-zero value.
+  }];
+  let hasFolder = 1;
+}
+
 def VM_CmpEQRefOp :
     VM_BinaryComparisonOp<VM_AnyRef, "cmp.eq.ref", VM_OPC_CmpEQRef,
                           [Commutative]> {
diff --git a/iree/compiler/Dialect/VM/Target/Bytecode/BytecodeEncoder.cpp b/iree/compiler/Dialect/VM/Target/Bytecode/BytecodeEncoder.cpp
index 643a1da..ade40f9 100644
--- a/iree/compiler/Dialect/VM/Target/Bytecode/BytecodeEncoder.cpp
+++ b/iree/compiler/Dialect/VM/Target/Bytecode/BytecodeEncoder.cpp
@@ -126,6 +126,28 @@
           return currentOp_->emitOpError()
                  << "attribute of bitwidth " << bitWidth << " not supported";
       }
+    } else if (auto floatAttr = attr.dyn_cast<FloatAttr>()) {
+      switch (bitWidth) {
+        case 32: {
+          union {
+            float f32;
+            uint32_t u32;
+          } value;
+          value.f32 = floatAttr.getValue().convertToFloat();
+          return writeUint32(value.u32);
+        }
+        case 64: {
+          union {
+            double f64;
+            uint64_t u64;
+          } value;
+          value.f64 = floatAttr.getValue().convertToDouble();
+          return writeUint64(value.u64);
+        }
+        default:
+          return currentOp_->emitOpError()
+                 << "attribute of bitwidth " << bitWidth << " not supported";
+      }
     } else {
       return currentOp_->emitOpError()
              << "attribute type not supported for primitive serialization: "
diff --git a/iree/compiler/Dialect/VM/Target/CallingConventionUtils.cpp b/iree/compiler/Dialect/VM/Target/CallingConventionUtils.cpp
index 29578ec..92e0125 100644
--- a/iree/compiler/Dialect/VM/Target/CallingConventionUtils.cpp
+++ b/iree/compiler/Dialect/VM/Target/CallingConventionUtils.cpp
@@ -37,8 +37,8 @@
   if (auto refPtrType = type.dyn_cast<IREE::VM::RefType>()) {
     s.push_back('r');
     return success();
-  } else if (auto intType = type.dyn_cast<IntegerType>()) {
-    switch (intType.getIntOrFloatBitWidth()) {
+  } else if (auto integerType = type.dyn_cast<IntegerType>()) {
+    switch (integerType.getIntOrFloatBitWidth()) {
       default:
       case 32:
         s.push_back('i');
@@ -47,6 +47,16 @@
         s.push_back('I');
         return success();
     }
+  } else if (auto floatType = type.dyn_cast<FloatType>()) {
+    switch (floatType.getIntOrFloatBitWidth()) {
+      default:
+      case 32:
+        s.push_back('f');
+        return success();
+      case 64:
+        s.push_back('F');
+        return success();
+    }
   } else if (auto tupleType = type.dyn_cast<TupleType>()) {
     // Flatten tuple (so tuple<i32, i64> -> `...iI...`).
     SmallVector<Type, 4> flattenedTypes;
diff --git a/iree/compiler/Dialect/VM/Transforms/GlobalInitialization.cpp b/iree/compiler/Dialect/VM/Transforms/GlobalInitialization.cpp
index bb87505..6218dbc 100644
--- a/iree/compiler/Dialect/VM/Transforms/GlobalInitialization.cpp
+++ b/iree/compiler/Dialect/VM/Transforms/GlobalInitialization.cpp
@@ -130,16 +130,31 @@
   // Returns {} if the constant is zero.
   std::pair<LogicalResult, Value> createConst(Location loc, Attribute value,
                                               OpBuilder &builder) {
-    if (auto intValue = value.dyn_cast<IntegerAttr>()) {
-      if (intValue.getValue().isNullValue()) {
+    if (auto integerAttr = value.dyn_cast<IntegerAttr>()) {
+      if (integerAttr.getValue().isNullValue()) {
         // Globals are zero-initialized by default.
         return {success(), {}};
       }
-      switch (intValue.getValue().getBitWidth()) {
+      switch (integerAttr.getType().getIntOrFloatBitWidth()) {
         case 32:
-          return {success(), builder.createOrFold<ConstI32Op>(loc, intValue)};
+          return {success(),
+                  builder.createOrFold<ConstI32Op>(loc, integerAttr)};
         case 64:
-          return {success(), builder.createOrFold<ConstI64Op>(loc, intValue)};
+          return {success(),
+                  builder.createOrFold<ConstI64Op>(loc, integerAttr)};
+        default:
+          return {failure(), {}};
+      }
+    } else if (auto floatAttr = value.dyn_cast<FloatAttr>()) {
+      if (floatAttr.getValue().isZero()) {
+        // Globals are zero-initialized by default.
+        return {success(), {}};
+      }
+      switch (floatAttr.getType().getIntOrFloatBitWidth()) {
+        case 32:
+          return {success(), builder.createOrFold<ConstF32Op>(loc, floatAttr)};
+        case 64:
+          return {success(), builder.createOrFold<ConstF64Op>(loc, floatAttr)};
         default:
           return {failure(), {}};
       }
@@ -150,8 +165,8 @@
   // Stores a value to a global; the global must be mutable.
   LogicalResult storePrimitiveGlobal(Location loc, StringRef symName,
                                      Value value, OpBuilder &builder) {
-    if (auto intType = value.getType().dyn_cast<IntegerType>()) {
-      switch (intType.getIntOrFloatBitWidth()) {
+    if (auto integerType = value.getType().dyn_cast<IntegerType>()) {
+      switch (integerType.getIntOrFloatBitWidth()) {
         case 32:
           builder.create<GlobalStoreI32Op>(loc, value, symName);
           return success();
@@ -161,6 +176,17 @@
         default:
           return failure();
       }
+    } else if (auto floatType = value.getType().dyn_cast<FloatType>()) {
+      switch (floatType.getIntOrFloatBitWidth()) {
+        case 32:
+          builder.create<GlobalStoreF32Op>(loc, value, symName);
+          return success();
+        case 64:
+          builder.create<GlobalStoreF64Op>(loc, value, symName);
+          return success();
+        default:
+          return failure();
+      }
     }
     return failure();
   }
diff --git a/iree/compiler/Dialect/VM/Transforms/OrdinalAllocation.cpp b/iree/compiler/Dialect/VM/Transforms/OrdinalAllocation.cpp
index dca926a..904d487 100644
--- a/iree/compiler/Dialect/VM/Transforms/OrdinalAllocation.cpp
+++ b/iree/compiler/Dialect/VM/Transforms/OrdinalAllocation.cpp
@@ -51,7 +51,8 @@
     int nextExportOrdinal = 0;
     int nextGlobalRefOrdinal = 0;
     int nextRodataOrdinal = 0;
-    SmallVector<SmallVector<VMGlobalOp, 4>, 8> primitiveGlobalOps(8);
+    SmallVector<SmallVector<VMGlobalOp, 4>, 8> primitiveGlobalOps(
+        sizeof(int64_t) + 1);
     for (auto &op : getOperation().getBlock().getOperations()) {
       Optional<int> ordinal = llvm::None;
       if (auto funcOp = dyn_cast<FuncOp>(op)) {
diff --git a/iree/compiler/Dialect/VM/Transforms/Passes.cpp b/iree/compiler/Dialect/VM/Transforms/Passes.cpp
index c88a068..f7fdd54 100644
--- a/iree/compiler/Dialect/VM/Transforms/Passes.cpp
+++ b/iree/compiler/Dialect/VM/Transforms/Passes.cpp
@@ -35,7 +35,9 @@
   passManager.addPass(createInlinerPass());
   passManager.addPass(createCSEPass());
   passManager.addPass(createSymbolDCEPass());
-  passManager.addNestedPass<VM::ModuleOp>(createSinkDefiningOpsPass());
+  if (targetOptions.optimizeForStackSize) {
+    passManager.addNestedPass<VM::ModuleOp>(createSinkDefiningOpsPass());
+  }
 }
 
 void registerVMTransformPassPipeline() {