Use asm style type names and improve asm typer.

test/cctest/test-asm-validator.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // TODO(jochen): Remove this after the setting is turned on globally.
 #define V8_IMMINENT_DEPRECATION_WARNINGS
 
 #include "src/v8.h"
 
 #include "src/ast.h"
 #include "src/ast-expression-visitor.h"
 #include "src/parser.h"
 #include "src/rewriter.h"
 #include "src/scopes.h"
 #include "src/type-cache.h"
 #include "src/typing-asm.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/expression-type-collector.h"
 #include "test/cctest/expression-type-collector-macros.h"
 
 // Macros for function types.
 #define FUNC_V_TYPE Bounds(Type::Function(Type::Undefined(), zone))
-#define FUNC_I_TYPE Bounds(Type::Function(cache.kInt32, zone))
-#define FUNC_F_TYPE Bounds(Type::Function(cache.kFloat32, zone))
-#define FUNC_D_TYPE Bounds(Type::Function(cache.kFloat64, zone))
+#define FUNC_I_TYPE Bounds(Type::Function(cache.kAsmSigned, zone))
+#define FUNC_F_TYPE Bounds(Type::Function(cache.kAsmFloat, zone))
+#define FUNC_D_TYPE Bounds(Type::Function(cache.kAsmDouble, zone))
 #define FUNC_D2D_TYPE \
-  Bounds(Type::Function(cache.kFloat64, cache.kFloat64, zone))
+  Bounds(Type::Function(cache.kAsmDouble, cache.kAsmDouble, zone))
 #define FUNC_N2F_TYPE \
-  Bounds(Type::Function(cache.kFloat32, Type::Number(), zone))
-#define FUNC_I2I_TYPE Bounds(Type::Function(cache.kInt32, cache.kInt32, zone))
+  Bounds(Type::Function(cache.kAsmFloat, Type::Number(), zone))
+#define FUNC_I2I_TYPE \
+  Bounds(Type::Function(cache.kAsmSigned, cache.kAsmInt, zone))
 #define FUNC_II2D_TYPE \
-  Bounds(Type::Function(cache.kFloat64, cache.kInt32, cache.kInt32, zone))
+  Bounds(Type::Function(cache.kAsmDouble, cache.kAsmInt, cache.kAsmInt, zone))
 #define FUNC_II2I_TYPE \
-  Bounds(Type::Function(cache.kInt32, cache.kInt32, cache.kInt32, zone))
-#define FUNC_DD2D_TYPE \
-  Bounds(Type::Function(cache.kFloat64, cache.kFloat64, cache.kFloat64, zone))
+  Bounds(Type::Function(cache.kAsmSigned, cache.kAsmInt, cache.kAsmInt, zone))
+#define FUNC_DD2D_TYPE                                                        \
+  Bounds(Type::Function(cache.kAsmDouble, cache.kAsmDouble, cache.kAsmDouble, \
+                        zone))
 #define FUNC_N2N_TYPE \
   Bounds(Type::Function(Type::Number(), Type::Number(), zone))
 
 // Macros for array types.
-#define FLOAT64_ARRAY_TYPE Bounds(Type::Array(cache.kFloat64, zone))
-#define FUNC_I2I_ARRAY_TYPE \
-  Bounds(Type::Array(Type::Function(cache.kInt32, cache.kInt32, zone), zone))
+#define FLOAT64_ARRAY_TYPE Bounds(Type::Array(cache.kAsmDouble, zone))
+#define FUNC_I2I_ARRAY_TYPE                                                 \
+  Bounds(Type::Array(Type::Function(cache.kAsmSigned, cache.kAsmInt, zone), \
+                     zone))
 
 using namespace v8::internal;
 
 namespace {
 
 std::string Validate(Zone* zone, const char* source,
                      ZoneVector<ExpressionTypeEntry>* types) {
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
 
@@ skipping 65 matching lines @@
   Zone* zone = handles.main_zone();
   ZoneVector<ExpressionTypeEntry> types(zone);
   CHECK_EQ("", Validate(zone, test_function, &types));
   TypeCache cache;
 
   CHECK_TYPES_BEGIN {
     // Module.
     CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
       // function logSum
       CHECK_EXPR(FunctionLiteral, FUNC_II2D_TYPE) {
-        CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-          CHECK_VAR(start, Bounds(cache.kInt32));
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-            CHECK_VAR(start, Bounds(cache.kInt32));
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+          CHECK_VAR(start, Bounds(cache.kAsmInt));
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+            CHECK_VAR(start, Bounds(cache.kAsmInt));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
         }
-        CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-          CHECK_VAR(end, Bounds(cache.kInt32));
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-            CHECK_VAR(end, Bounds(cache.kInt32));
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+          CHECK_VAR(end, Bounds(cache.kAsmInt));
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+            CHECK_VAR(end, Bounds(cache.kAsmInt));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
         }
-        CHECK_EXPR(Assignment, Bounds(cache.kFloat64)) {
-          CHECK_VAR(sum, Bounds(cache.kFloat64));
-          CHECK_EXPR(Literal, Bounds(cache.kFloat64));
+        CHECK_EXPR(Assignment, Bounds(cache.kAsmDouble)) {
+          CHECK_VAR(sum, Bounds(cache.kAsmDouble));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
         }
-        CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-          CHECK_VAR(p, Bounds(cache.kInt32));
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+          CHECK_VAR(p, Bounds(cache.kAsmInt));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
         }
-        CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-          CHECK_VAR(q, Bounds(cache.kInt32));
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+          CHECK_VAR(q, Bounds(cache.kAsmInt));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
         }
         // for (p = start << 3, q = end << 3;
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-          CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-            CHECK_VAR(p, Bounds(cache.kInt32));
-            CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-              CHECK_VAR(start, Bounds(cache.kInt32));
-              CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmInt)) {
+          CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+            CHECK_VAR(p, Bounds(cache.kAsmInt));
+            CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+              CHECK_VAR(start, Bounds(cache.kAsmInt));
+              CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
             }
           }
-          CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-            CHECK_VAR(q, Bounds(cache.kInt32));
-            CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-              CHECK_VAR(end, Bounds(cache.kInt32));
-              CHECK_EXPR(Literal, Bounds(cache.kInt32));
+          CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+            CHECK_VAR(q, Bounds(cache.kAsmInt));
+            CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+              CHECK_VAR(end, Bounds(cache.kAsmInt));
+              CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
             }
           }
         }
         // (p|0) < (q|0);
-        CHECK_EXPR(CompareOperation, Bounds(cache.kInt32)) {
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-            CHECK_VAR(p, Bounds(cache.kInt32));
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(CompareOperation, Bounds(cache.kAsmSigned)) {
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+            CHECK_VAR(p, Bounds(cache.kAsmInt));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-            CHECK_VAR(q, Bounds(cache.kInt32));
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+            CHECK_VAR(q, Bounds(cache.kAsmInt));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
         }
         // p = (p + 8)|0) {\n"
-        CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-          CHECK_VAR(p, Bounds(cache.kInt32));
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-            CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-              CHECK_VAR(p, Bounds(cache.kInt32));
-              CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+          CHECK_VAR(p, Bounds(cache.kAsmInt));
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+            CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmInt)) {
+              CHECK_VAR(p, Bounds(cache.kAsmInt));
+              CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
             }
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
         }
         // sum = sum + +log(values[p>>3]);
-        CHECK_EXPR(Assignment, Bounds(cache.kFloat64)) {
-          CHECK_VAR(sum, Bounds(cache.kFloat64));
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kFloat64)) {
-            CHECK_VAR(sum, Bounds(cache.kFloat64));
-            CHECK_EXPR(BinaryOperation, Bounds(cache.kFloat64)) {
-              CHECK_EXPR(Call, Bounds(cache.kFloat64)) {
+        CHECK_EXPR(Assignment, Bounds(cache.kAsmDouble)) {
+          CHECK_VAR(sum, Bounds(cache.kAsmDouble));
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmDouble)) {
+            CHECK_VAR(sum, Bounds(cache.kAsmDouble));
+            CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmDouble)) {
+              CHECK_EXPR(Call, Bounds(cache.kAsmDouble)) {
                 CHECK_VAR(log, FUNC_D2D_TYPE);
-                CHECK_EXPR(Property, Bounds(cache.kFloat64)) {
+                CHECK_EXPR(Property, Bounds(cache.kAsmDouble)) {
                   CHECK_VAR(values, FLOAT64_ARRAY_TYPE);
-                  CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-                    CHECK_VAR(p, Bounds(cache.kInt32));
-                    CHECK_EXPR(Literal, Bounds(cache.kInt32));
+                  CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+                    CHECK_VAR(p, Bounds(cache.kAsmSigned));
+                    CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
                   }
                 }
               }
-              CHECK_EXPR(Literal, Bounds(cache.kFloat64));
+              CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
             }
           }
         }
         // return +sum;
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kFloat64)) {
-          CHECK_VAR(sum, Bounds(cache.kFloat64));
-          CHECK_EXPR(Literal, Bounds(cache.kFloat64));
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmDouble)) {
+          CHECK_VAR(sum, Bounds(cache.kAsmDouble));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
         }
       }
       // function geometricMean
       CHECK_EXPR(FunctionLiteral, FUNC_II2D_TYPE) {
-        CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-          CHECK_VAR(start, Bounds(cache.kInt32));
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-            CHECK_VAR(start, Bounds(cache.kInt32));
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+          CHECK_VAR(start, Bounds(cache.kAsmInt));
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+            CHECK_VAR(start, Bounds(cache.kAsmInt));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
         }
-        CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-          CHECK_VAR(end, Bounds(cache.kInt32));
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-            CHECK_VAR(end, Bounds(cache.kInt32));
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+          CHECK_VAR(end, Bounds(cache.kAsmInt));
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+            CHECK_VAR(end, Bounds(cache.kAsmInt));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
         }
         // return +exp(+logSum(start, end) / +((end - start)|0));
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kFloat64)) {
-          CHECK_EXPR(Call, Bounds(cache.kFloat64)) {
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmDouble)) {
+          CHECK_EXPR(Call, Bounds(cache.kAsmDouble)) {
             CHECK_VAR(exp, FUNC_D2D_TYPE);
-            CHECK_EXPR(BinaryOperation, Bounds(cache.kFloat64)) {
-              CHECK_EXPR(BinaryOperation, Bounds(cache.kFloat64)) {
-                CHECK_EXPR(Call, Bounds(cache.kFloat64)) {
+            CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmDouble)) {
+              CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmDouble)) {
+                CHECK_EXPR(Call, Bounds(cache.kAsmDouble)) {
                   CHECK_VAR(logSum, FUNC_II2D_TYPE);
-                  CHECK_VAR(start, Bounds(cache.kInt32));
-                  CHECK_VAR(end, Bounds(cache.kInt32));
+                  CHECK_VAR(start, Bounds(cache.kAsmInt));
+                  CHECK_VAR(end, Bounds(cache.kAsmInt));
                 }
-                CHECK_EXPR(Literal, Bounds(cache.kFloat64));
+                CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
               }
-              CHECK_EXPR(BinaryOperation, Bounds(cache.kFloat64)) {
-                CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-                  CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-                    CHECK_VAR(end, Bounds(cache.kInt32));
-                    CHECK_VAR(start, Bounds(cache.kInt32));
+              CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmDouble)) {
+                CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+                  CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmInt)) {
+                    CHECK_VAR(end, Bounds(cache.kAsmInt));
+                    CHECK_VAR(start, Bounds(cache.kAsmInt));
                   }
-                  CHECK_EXPR(Literal, Bounds(cache.kInt32));
+                  CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
                 }
-                CHECK_EXPR(Literal, Bounds(cache.kFloat64));
+                CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
               }
             }
           }
-          CHECK_EXPR(Literal, Bounds(cache.kFloat64));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
         }
       }
       // "use asm";
       CHECK_EXPR(Literal, Bounds(Type::String()));
       // var exp = stdlib.Math.exp;
       CHECK_EXPR(Assignment, FUNC_D2D_TYPE) {
         CHECK_VAR(exp, FUNC_D2D_TYPE);
         CHECK_EXPR(Property, FUNC_D2D_TYPE) {
           CHECK_EXPR(Property, Bounds::Unbounded()) {
             CHECK_VAR(stdlib, Bounds::Unbounded());
@@ skipping 121 matching lines @@
       CHECK_VAR(buffer, Bounds::Unbounded());     \
     }                                             \
   }
 
 
 namespace {
 
 void CheckStdlibShortcuts(Zone* zone, ZoneVector<ExpressionTypeEntry>& types,
                           size_t& index, int& depth, TypeCache& cache) {
   // var exp = stdlib.*; (D * 12)
-  CHECK_VAR_SHORTCUT(Infinity, Bounds(cache.kFloat64));
-  CHECK_VAR_SHORTCUT(NaN, Bounds(cache.kFloat64));
+  CHECK_VAR_SHORTCUT(Infinity, Bounds(cache.kAsmDouble));
+  CHECK_VAR_SHORTCUT(NaN, Bounds(cache.kAsmDouble));
   // var x = stdlib.Math.x;  D2D
   CHECK_VAR_MATH_SHORTCUT(acos, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(asin, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(atan, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(cos, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(sin, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(tan, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(exp, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(log, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(ceil, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(floor, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(sqrt, FUNC_D2D_TYPE);
   // var exp = stdlib.Math.*; (DD2D * 12)
   CHECK_VAR_MATH_SHORTCUT(min, FUNC_DD2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(max, FUNC_DD2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(atan2, FUNC_DD2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(pow, FUNC_DD2D_TYPE);
   // Special ones.
   CHECK_VAR_MATH_SHORTCUT(abs, FUNC_N2N_TYPE);
   CHECK_VAR_MATH_SHORTCUT(imul, FUNC_II2I_TYPE);
   CHECK_VAR_MATH_SHORTCUT(fround, FUNC_N2F_TYPE);
   // var exp = stdlib.Math.*; (D * 12)
-  CHECK_VAR_MATH_SHORTCUT(E, Bounds(cache.kFloat64));
-  CHECK_VAR_MATH_SHORTCUT(LN10, Bounds(cache.kFloat64));
-  CHECK_VAR_MATH_SHORTCUT(LN2, Bounds(cache.kFloat64));
-  CHECK_VAR_MATH_SHORTCUT(LOG2E, Bounds(cache.kFloat64));
-  CHECK_VAR_MATH_SHORTCUT(LOG10E, Bounds(cache.kFloat64));
-  CHECK_VAR_MATH_SHORTCUT(PI, Bounds(cache.kFloat64));
-  CHECK_VAR_MATH_SHORTCUT(SQRT1_2, Bounds(cache.kFloat64));
-  CHECK_VAR_MATH_SHORTCUT(SQRT2, Bounds(cache.kFloat64));
+  CHECK_VAR_MATH_SHORTCUT(E, Bounds(cache.kAsmDouble));
+  CHECK_VAR_MATH_SHORTCUT(LN10, Bounds(cache.kAsmDouble));
+  CHECK_VAR_MATH_SHORTCUT(LN2, Bounds(cache.kAsmDouble));
+  CHECK_VAR_MATH_SHORTCUT(LOG2E, Bounds(cache.kAsmDouble));
+  CHECK_VAR_MATH_SHORTCUT(LOG10E, Bounds(cache.kAsmDouble));
+  CHECK_VAR_MATH_SHORTCUT(PI, Bounds(cache.kAsmDouble));
+  CHECK_VAR_MATH_SHORTCUT(SQRT1_2, Bounds(cache.kAsmDouble));
+  CHECK_VAR_MATH_SHORTCUT(SQRT2, Bounds(cache.kAsmDouble));
   // var values = new stdlib.*Array(buffer);
   CHECK_VAR_NEW_SHORTCUT(u8, Bounds(cache.kUint8Array));
   CHECK_VAR_NEW_SHORTCUT(i8, Bounds(cache.kInt8Array));
   CHECK_VAR_NEW_SHORTCUT(u16, Bounds(cache.kUint16Array));
   CHECK_VAR_NEW_SHORTCUT(i16, Bounds(cache.kInt16Array));
   CHECK_VAR_NEW_SHORTCUT(u32, Bounds(cache.kUint32Array));
   CHECK_VAR_NEW_SHORTCUT(i32, Bounds(cache.kInt32Array));
   CHECK_VAR_NEW_SHORTCUT(f32, Bounds(cache.kFloat32Array));
   CHECK_VAR_NEW_SHORTCUT(f64, Bounds(cache.kFloat64Array));
 }
@@ skipping 87 matching lines @@
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(DoesNothing) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { var x = 1.0; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kFloat64)) {
-        CHECK_VAR(x, Bounds(cache.kFloat64));
-        CHECK_EXPR(Literal, Bounds(cache.kFloat64));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmDouble)) {
+        CHECK_VAR(x, Bounds(cache.kAsmDouble));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
       }
     }
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
       CHECK_EXPR(Call, Bounds(Type::Undefined())) {
         CHECK_VAR(bar, FUNC_V_TYPE);
       }
     }
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(ReturnInt32Literal) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { return 1; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {
       // return 1;
-      CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Literal, Bounds(cache.kAsmSigned));
     }
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
-      CHECK_EXPR(Call, Bounds(cache.kInt32)) { CHECK_VAR(bar, FUNC_I_TYPE); }
+      CHECK_EXPR(Call, Bounds(cache.kAsmSigned)) {
+        CHECK_VAR(bar, FUNC_I_TYPE);
+      }
     }
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(ReturnFloat64Literal) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { return 1.0; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_D_TYPE) {
       // return 1.0;
-      CHECK_EXPR(Literal, Bounds(cache.kFloat64));
+      CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
     }
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
-      CHECK_EXPR(Call, Bounds(cache.kFloat64)) { CHECK_VAR(bar, FUNC_D_TYPE); }
+      CHECK_EXPR(Call, Bounds(cache.kAsmDouble)) {
+        CHECK_VAR(bar, FUNC_D_TYPE);
+      }
     }
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(ReturnFloat32Literal) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { return fround(1.0); }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_F_TYPE) {
       // return fround(1.0);
-      CHECK_EXPR(Call, Bounds(cache.kFloat32)) {
+      CHECK_EXPR(Call, Bounds(cache.kAsmFloat)) {
         CHECK_VAR(fround, FUNC_N2F_TYPE);
-        CHECK_EXPR(Literal, Bounds(cache.kFloat64));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
       }
     }
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
-      CHECK_EXPR(Call, Bounds(cache.kFloat32)) { CHECK_VAR(bar, FUNC_F_TYPE); }
+      CHECK_EXPR(Call, Bounds(cache.kAsmFloat)) { CHECK_VAR(bar, FUNC_F_TYPE); }
     }
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(ReturnFloat64Var) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { var x = 1.0; return +x; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_D_TYPE) {
       // return 1.0;
-      CHECK_EXPR(Assignment, Bounds(cache.kFloat64)) {
-        CHECK_VAR(x, Bounds(cache.kFloat64));
-        CHECK_EXPR(Literal, Bounds(cache.kFloat64));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmDouble)) {
+        CHECK_VAR(x, Bounds(cache.kAsmDouble));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
       }
       // return 1.0;
-      CHECK_EXPR(BinaryOperation, Bounds(cache.kFloat64)) {
-        CHECK_VAR(x, Bounds(cache.kFloat64));
-        CHECK_EXPR(Literal, Bounds(cache.kFloat64));
+      CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmDouble)) {
+        CHECK_VAR(x, Bounds(cache.kAsmDouble));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
       }
     }
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
-      CHECK_EXPR(Call, Bounds(cache.kFloat64)) { CHECK_VAR(bar, FUNC_D_TYPE); }
+      CHECK_EXPR(Call, Bounds(cache.kAsmDouble)) {
+        CHECK_VAR(bar, FUNC_D_TYPE);
+      }
     }
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(Addition2) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { var x = 1; var y = 2; return (x+y)|0; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(x, Bounds(cache.kInt32));
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(y, Bounds(cache.kInt32));
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(y, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
-      CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-          CHECK_VAR(x, Bounds(cache.kInt32));
-          CHECK_VAR(y, Bounds(cache.kInt32));
+      CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmInt)) {
+          CHECK_VAR(x, Bounds(cache.kAsmInt));
+          CHECK_VAR(y, Bounds(cache.kAsmInt));
         }
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
     }
     CHECK_SKIP();
   }
   CHECK_FUNC_TYPES_END
 }
 
 
-#define TEST_COMPARE_OP(name, op)                              \
-  TEST(name) {                                                 \
-    CHECK_FUNC_TYPES_BEGIN("function bar() { return (0 " op    \
-                           " 0)|0; }\n"                        \
-                           "function foo() { bar(); }") {      \
-      CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {               \
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {    \
-          CHECK_EXPR(CompareOperation, Bounds(cache.kInt32)) { \
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));         \
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));         \
-          }                                                    \
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));           \
-        }                                                      \
-      }                                                        \
-      CHECK_SKIP();                                            \
-    }                                                          \
-    CHECK_FUNC_TYPES_END                                       \
+#define TEST_COMPARE_OP(name, op)                                  \
+  TEST(name) {                                                     \
+    CHECK_FUNC_TYPES_BEGIN("function bar() { return (0 " op        \
+                           " 0)|0; }\n"                            \
+                           "function foo() { bar(); }") {          \
+      CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {                   \
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {    \
+          CHECK_EXPR(CompareOperation, Bounds(cache.kAsmSigned)) { \
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));         \
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));         \
+          }                                                        \
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));           \
+        }                                                          \
+      }                                                            \
+      CHECK_SKIP();                                                \
+    }                                                              \
+    CHECK_FUNC_TYPES_END                                           \
   }
 
 
 TEST_COMPARE_OP(EqOperator, "==")
 TEST_COMPARE_OP(LtOperator, "<")
 TEST_COMPARE_OP(LteOperator, "<=")
 TEST_COMPARE_OP(GtOperator, ">")
 TEST_COMPARE_OP(GteOperator, ">=")
 
 
 TEST(NeqOperator) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { return (0 != 0)|0; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {
-      CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-        CHECK_EXPR(UnaryOperation, Bounds(cache.kInt32)) {
-          CHECK_EXPR(CompareOperation, Bounds(cache.kInt32)) {
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+        CHECK_EXPR(UnaryOperation, Bounds(cache.kAsmSigned)) {
+          CHECK_EXPR(CompareOperation, Bounds(cache.kAsmSigned)) {
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
         }
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
     }
     CHECK_SKIP();
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(NotOperator) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { var x = 0; return (!x)|0; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(x, Bounds(cache.kInt32));
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
-      CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-        CHECK_EXPR(UnaryOperation, Bounds(cache.kInt32)) {
-          CHECK_VAR(x, Bounds(cache.kInt32));
+      CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+        CHECK_EXPR(UnaryOperation, Bounds(cache.kAsmSigned)) {
+          CHECK_VAR(x, Bounds(cache.kAsmInt));
         }
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
     }
     CHECK_SKIP();
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(InvertOperator) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { var x = 0; return (~x)|0; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(x, Bounds(cache.kInt32));
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
-      CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-          CHECK_VAR(x, Bounds(cache.kInt32));
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+          CHECK_VAR(x, Bounds(cache.kAsmInt));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmSigned));
         }
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
     }
     CHECK_SKIP();
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(InvertConversion) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { var x = 0.0; return (~~x)|0; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kFloat64)) {
-        CHECK_VAR(x, Bounds(cache.kFloat64));
-        CHECK_EXPR(Literal, Bounds(cache.kFloat64));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmDouble)) {
+        CHECK_VAR(x, Bounds(cache.kAsmDouble));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
       }
-      CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-            CHECK_VAR(x, Bounds(cache.kFloat64));
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+            CHECK_VAR(x, Bounds(cache.kAsmDouble));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmSigned));
           }
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmSigned));
         }
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
     }
     CHECK_SKIP();
+  }
+  CHECK_FUNC_TYPES_END
+}
+
+
+TEST(Ternary) {
+  CHECK_FUNC_TYPES_BEGIN(
+      "function bar() { var x = 1; var y = 1; return (x?y:5)|0; }\n"
+      "function foo() { bar(); }") {
+    CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
+      }
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(y, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
+      }
+      CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+        CHECK_EXPR(Conditional, Bounds(cache.kAsmInt)) {
+          CHECK_VAR(x, Bounds(cache.kAsmInt));
+          CHECK_VAR(y, Bounds(cache.kAsmInt));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
+        }
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
+      }
+    }
+    CHECK_SKIP();
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 #define TEST_INT_BIN_OP(name, op)                                      \
   TEST(name) {                                                         \
     CHECK_FUNC_TYPES_BEGIN("function bar() { var x = 0; return (x " op \
                            " 123)|0; }\n"                              \
                            "function foo() { bar(); }") {              \
       CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {                       \
-        CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {                 \
-          CHECK_VAR(x, Bounds(cache.kInt32));                          \
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));                   \
+        CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {                \
+          CHECK_VAR(x, Bounds(cache.kAsmInt));                         \
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));               \
         }                                                              \
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {            \
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {          \
-            CHECK_VAR(x, Bounds(cache.kInt32));                        \
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));                 \
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {        \
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {      \
+            CHECK_VAR(x, Bounds(cache.kAsmInt));                       \
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));             \
           }                                                            \
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));                   \
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));               \
         }                                                              \
       }                                                                \
       CHECK_SKIP();                                                    \
     }                                                                  \
     CHECK_FUNC_TYPES_END                                               \
   }
 
 
 TEST_INT_BIN_OP(AndOperator, "&")
 TEST_INT_BIN_OP(OrOperator, "|")
 TEST_INT_BIN_OP(XorOperator, "^")
 
 
 TEST(UnsignedCompare) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { var x = 1; var y = 1; return ((x>>>0) < (y>>>0))|0; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(x, Bounds(cache.kInt32));
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(y, Bounds(cache.kInt32));
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(y, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
-      CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-        CHECK_EXPR(CompareOperation, Bounds(cache.kInt32)) {
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kUint32)) {
-            CHECK_VAR(x, Bounds(cache.kInt32));
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+        CHECK_EXPR(CompareOperation, Bounds(cache.kAsmSigned)) {
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmUnsigned)) {
+            CHECK_VAR(x, Bounds(cache.kAsmInt));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kUint32)) {
-            CHECK_VAR(y, Bounds(cache.kInt32));
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmUnsigned)) {
+            CHECK_VAR(y, Bounds(cache.kAsmInt));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
         }
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
     }
     CHECK_SKIP();
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(UnsignedDivide) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { var x = 1; var y = 1; return ((x>>>0) / (y>>>0))|0; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(x, Bounds(cache.kInt32));
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(y, Bounds(cache.kInt32));
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(y, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
-      CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
+      CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
         CHECK_EXPR(BinaryOperation, Bounds(Type::None(), Type::Any())) {
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kUint32)) {
-            CHECK_VAR(x, Bounds(cache.kInt32));
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmUnsigned)) {
+            CHECK_VAR(x, Bounds(cache.kAsmInt));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kUint32)) {
-            CHECK_VAR(y, Bounds(cache.kInt32));
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmUnsigned)) {
+            CHECK_VAR(y, Bounds(cache.kAsmInt));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
         }
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
     }
     CHECK_SKIP();
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(UnsignedFromFloat64) {
   CHECK_FUNC_ERROR(
       "function bar() { var x = 1.0; return (x>>>0)|0; }\n"
       "function foo() { bar(); }",
-      "asm: line 39: ill typed bitwise operation\n");
+      "asm: line 39: left bitwise operand expected to be an integer\n");
 }
 
 
+TEST(AndFloat64) {
+  CHECK_FUNC_ERROR(
+      "function bar() { var x = 1.0; return (x&0)|0; }\n"
+      "function foo() { bar(); }",
+      "asm: line 39: left bitwise operand expected to be an integer\n");
+}
+
+
 TEST(TypeMismatchAddInt32Float64) {
   CHECK_FUNC_ERROR(
       "function bar() { var x = 1.0; var y = 0; return (x + y)|0; }\n"
       "function foo() { bar(); }",
       "asm: line 39: ill-typed arithmetic operation\n");
 }
 
 
 TEST(TypeMismatchSubInt32Float64) {
   CHECK_FUNC_ERROR(
@@ skipping 24 matching lines @@
       "function bar() { var x = fround(1.0); return (x % x)|0; }\n"
       "function foo() { bar(); }",
       "asm: line 39: ill-typed arithmetic operation\n");
 }
 
 
 TEST(TernaryMismatchInt32Float64) {
   CHECK_FUNC_ERROR(
       "function bar() { var x = 1; var y = 0.0; return (1 ? x : y)|0; }\n"
       "function foo() { bar(); }",
-      "asm: line 39: ill-typed conditional\n");
+      "asm: line 39: then and else expressions in ? must have the same type\n");
 }
 
 
+TEST(TernaryMismatchIntish) {
+  CHECK_FUNC_ERROR(
+      "function bar() { var x = 1; var y = 0; return (1 ? x + x : y)|0; }\n"
+      "function foo() { bar(); }",
+      "asm: line 39: invalid type in ? then expression\n");
+}
+
+
+TEST(TernaryMismatchInt32Float32) {
+  CHECK_FUNC_ERROR(
+      "function bar() { var x = 1; var y = 2; return (x?fround(y):x)|0; }\n"
+      "function foo() { bar(); }",
+      "asm: line 39: then and else expressions in ? must have the same type\n");
+}
+
+
+TEST(TernaryBadCondition) {
+  CHECK_FUNC_ERROR(
+      "function bar() { var x = 1; var y = 2.0; return (y?x:1)|0; }\n"
+      "function foo() { bar(); }",
+      "asm: line 39: condition must be of type int\n");
+}
+
+
 TEST(FroundFloat32) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { var x = 1; return fround(x); }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_F_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(x, Bounds(cache.kInt32));
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
-      CHECK_EXPR(Call, Bounds(cache.kFloat32)) {
+      CHECK_EXPR(Call, Bounds(cache.kAsmFloat)) {
         CHECK_VAR(fround, FUNC_N2F_TYPE);
-        CHECK_VAR(x, Bounds(cache.kInt32));
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
       }
     }
     CHECK_SKIP();
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(Addition4) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { var x = 1; var y = 2; return (x+y+x+y)|0; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(x, Bounds(cache.kInt32));
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(y, Bounds(cache.kInt32));
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(y, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
-      CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-            CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-              CHECK_VAR(x, Bounds(cache.kInt32));
-              CHECK_VAR(y, Bounds(cache.kInt32));
+      CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmInt)) {
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmInt)) {
+            CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmInt)) {
+              CHECK_VAR(x, Bounds(cache.kAsmInt));
+              CHECK_VAR(y, Bounds(cache.kAsmInt));
             }
-            CHECK_VAR(x, Bounds(cache.kInt32));
+            CHECK_VAR(x, Bounds(cache.kAsmInt));
           }
-          CHECK_VAR(y, Bounds(cache.kInt32));
+          CHECK_VAR(y, Bounds(cache.kAsmInt));
         }
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
     }
     CHECK_SKIP();
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(Multiplication2) {
   CHECK_FUNC_ERROR(
       "function bar() { var x = 1; var y = 2; return (x*y)|0; }\n"
       "function foo() { bar(); }",
       "asm: line 39: direct integer multiply forbidden\n");
 }
 
 
 TEST(Division4) {
   CHECK_FUNC_ERROR(
       "function bar() { var x = 1; var y = 2; return (x/y/x/y)|0; }\n"
       "function foo() { bar(); }",
       "asm: line 39: too many consecutive multiplicative ops\n");
 }
 
 
+TEST(CompareToStringLeft) {
+  CHECK_FUNC_ERROR(
+      "function bar() { var x = 1; return ('hi' > x)|0; }\n"
+      "function foo() { bar(); }",
+      "asm: line 39: bad type on left side of comparison\n");
+}
+
+
+TEST(CompareToStringRight) {
+  CHECK_FUNC_ERROR(
+      "function bar() { var x = 1; return (x < 'hi')|0; }\n"
+      "function foo() { bar(); }",
+      "asm: line 39: bad type on right side of comparison\n");
+}
+
+
 TEST(CompareMismatchInt32Float64) {
   CHECK_FUNC_ERROR(
       "function bar() { var x = 1; var y = 2.0; return (x < y)|0; }\n"
       "function foo() { bar(); }",
-      "asm: line 39: ill-typed comparison operation\n");
+      "asm: line 39: left and right side of comparison must match\n");
 }
 
 
 TEST(CompareMismatchInt32Uint32) {
   CHECK_FUNC_ERROR(
-      "function bar() { var x = 1; var y = 2; return (x < (y>>>0))|0; }\n"
+      "function bar() { var x = 1; var y = 2; return ((x|0) < (y>>>0))|0; }\n"
       "function foo() { bar(); }",
-      "asm: line 39: ill-typed comparison operation\n");
+      "asm: line 39: left and right side of comparison must match\n");
 }
 
 
 TEST(CompareMismatchInt32Float32) {
   CHECK_FUNC_ERROR(
       "function bar() { var x = 1; var y = 2; return (x < fround(y))|0; }\n"
       "function foo() { bar(); }",
-      "asm: line 39: ill-typed comparison operation\n");
+      "asm: line 39: left and right side of comparison must match\n");
 }
 
 
 TEST(Float64ToInt32) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { var x = 1; var y = 0.0; x = ~~y; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(x, Bounds(cache.kInt32));
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
-      CHECK_EXPR(Assignment, Bounds(cache.kFloat64)) {
-        CHECK_VAR(y, Bounds(cache.kFloat64));
-        CHECK_EXPR(Literal, Bounds(cache.kFloat64));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmDouble)) {
+        CHECK_VAR(y, Bounds(cache.kAsmDouble));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
       }
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(x, Bounds(cache.kInt32));
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-          CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-            CHECK_VAR(y, Bounds(cache.kFloat64));
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+          CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+            CHECK_VAR(y, Bounds(cache.kAsmDouble));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmSigned));
           }
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmSigned));
         }
       }
     }
     CHECK_SKIP();
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(Load1) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { var x = 1; var y = i8[x>>0]|0; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(x, Bounds(cache.kInt32));
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(y, Bounds(cache.kInt32));
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(y, Bounds(cache.kAsmInt));
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
           CHECK_EXPR(Property, Bounds(cache.kInt8)) {
             CHECK_VAR(i8, Bounds(cache.kInt8Array));
-            CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-              CHECK_VAR(x, Bounds(cache.kInt32));
-              CHECK_EXPR(Literal, Bounds(cache.kInt32));
+            CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+              CHECK_VAR(x, Bounds(cache.kAsmSigned));
+              CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
             }
           }
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
         }
       }
     }
     CHECK_SKIP();
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(Load1Constant) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { var x = 1; var y = i8[5]|0; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(x, Bounds(cache.kInt32));
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(y, Bounds(cache.kInt32));
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(y, Bounds(cache.kAsmInt));
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
           CHECK_EXPR(Property, Bounds(cache.kInt8)) {
             CHECK_VAR(i8, Bounds(cache.kInt8Array));
-            CHECK_EXPR(Literal, Bounds(cache.kInt32));
+            CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
         }
       }
     }
     CHECK_SKIP();
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(FunctionTables) {
   CHECK_FUNC_TYPES_BEGIN(
       "function func1(x) { x = x | 0; return (x * 5) | 0; }\n"
       "function func2(x) { x = x | 0; return (x * 25) | 0; }\n"
       "var table1 = [func1, func2];\n"
       "function bar(x, y) { x = x | 0; y = y | 0;\n"
       "   return table1[x & 1](y)|0; }\n"
       "function foo() { bar(1, 2); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_I2I_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(x, Bounds(cache.kInt32));
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-          CHECK_VAR(x, Bounds(cache.kInt32));
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+          CHECK_VAR(x, Bounds(cache.kAsmInt));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
         }
       }
-      CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-          CHECK_VAR(x, Bounds(cache.kInt32));
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmInt)) {
+          CHECK_VAR(x, Bounds(cache.kAsmInt));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
         }
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
     }
     CHECK_EXPR(FunctionLiteral, FUNC_I2I_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(x, Bounds(cache.kInt32));
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-          CHECK_VAR(x, Bounds(cache.kInt32));
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+          CHECK_VAR(x, Bounds(cache.kAsmInt));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
         }
       }
-      CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-          CHECK_VAR(x, Bounds(cache.kInt32));
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmInt)) {
+          CHECK_VAR(x, Bounds(cache.kAsmInt));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
         }
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
     }
     CHECK_EXPR(FunctionLiteral, FUNC_II2I_TYPE) {
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(x, Bounds(cache.kInt32));
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-          CHECK_VAR(x, Bounds(cache.kInt32));
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(x, Bounds(cache.kAsmInt));
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+          CHECK_VAR(x, Bounds(cache.kAsmInt));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
         }
       }
-      CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
-        CHECK_VAR(y, Bounds(cache.kInt32));
-        CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-          CHECK_VAR(y, Bounds(cache.kInt32));
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
+      CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
+        CHECK_VAR(y, Bounds(cache.kAsmInt));
+        CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+          CHECK_VAR(y, Bounds(cache.kAsmInt));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
         }
       }
-      CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-        CHECK_EXPR(Call, Bounds(cache.kInt32)) {
+      CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+        CHECK_EXPR(Call, Bounds(cache.kAsmSigned)) {
           CHECK_EXPR(Property, FUNC_I2I_TYPE) {
             CHECK_VAR(table1, FUNC_I2I_ARRAY_TYPE);
-            CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
-              CHECK_VAR(x, Bounds(cache.kInt32));
-              CHECK_EXPR(Literal, Bounds(cache.kInt32));
+            CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
+              CHECK_VAR(x, Bounds(cache.kAsmSigned));
+              CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
             }
           }
-          CHECK_VAR(y, Bounds(cache.kInt32));
+          CHECK_VAR(y, Bounds(cache.kAsmInt));
         }
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
     }
     CHECK_SKIP();
   }
   CHECK_FUNC_TYPES_END_1();
   CHECK_EXPR(Assignment, FUNC_I2I_ARRAY_TYPE) {
     CHECK_VAR(table1, FUNC_I2I_ARRAY_TYPE);
     CHECK_EXPR(ArrayLiteral, FUNC_I2I_ARRAY_TYPE) {
       CHECK_VAR(func1, FUNC_I2I_TYPE);
       CHECK_VAR(func2, FUNC_I2I_TYPE);
@@ skipping 149 matching lines @@
       "asm: line 39: illegal literal\n");
 }
 
 
 TEST(ForeignFunction) {
   CHECK_FUNC_TYPES_BEGIN(
       "var baz = foreign.baz;\n"
       "function bar() { return baz(1, 2)|0; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {
-      CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
+      CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
         CHECK_EXPR(Call, Bounds(Type::Number(zone))) {
           CHECK_VAR(baz, Bounds(Type::Any()));
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
-          CHECK_EXPR(Literal, Bounds(cache.kInt32));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
+          CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
         }
-        CHECK_EXPR(Literal, Bounds(cache.kInt32));
+        CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
     }
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
-      CHECK_EXPR(Call, Bounds(cache.kInt32)) { CHECK_VAR(bar, FUNC_I_TYPE); }
+      CHECK_EXPR(Call, Bounds(cache.kAsmSigned)) {
+        CHECK_VAR(bar, FUNC_I_TYPE);
+      }
     }
   }
   CHECK_FUNC_TYPES_END_1()
   CHECK_EXPR(Assignment, Bounds(Type::Any())) {
     CHECK_VAR(baz, Bounds(Type::Any()));
     CHECK_EXPR(Property, Bounds(Type::Any())) {
       CHECK_VAR(foreign, Bounds::Unbounded());
       CHECK_EXPR(Literal, Bounds::Unbounded());
     }
   }
   CHECK_FUNC_TYPES_END_2()
 }
 
 
 TEST(BadExports) {
   HARNESS_PREAMBLE()
   "function foo() {};\n"
   "return {foo: foo, bar: 1};"
   "}\n";
 
   v8::V8::Initialize();
   HandleAndZoneScope handles;
   Zone* zone = handles.main_zone();
   ZoneVector<ExpressionTypeEntry> types(zone);
   CHECK_EQ("asm: line 40: non-function in function table\n",
            Validate(zone, test_function, &types));
 }
+
+
+TEST(TypeConsistency) {
+  v8::V8::Initialize();
+  //  HandleAndZoneScope handles;
+  //  Zone* zone = handles.main_zone();
+  TypeCache cache;
+
+
+  CHECK(!cache.kAsmSigned->Is(cache.kAsmDouble));
+  CHECK(!cache.kAsmSigned->Is(cache.kAsmFloat));
+  CHECK(!cache.kAsmSigned->Is(cache.kAsmUnsigned));
+  CHECK(!cache.kAsmDouble->Is(cache.kAsmSigned));
+  CHECK(cache.kAsmSigned->Is(cache.kAsmInt));
+  CHECK(!cache.kAsmSigned->Is(cache.kAsmDouble));
+}