src/v8/test/cctest/compiler/codegen-tester.cc

   1 // Copyright 2014 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "src/v8.h"
   6
   7 #include "test/cctest/cctest.h"
   8 #include "test/cctest/compiler/codegen-tester.h"
   9 #include "test/cctest/compiler/value-helper.h"
  10
  11 using namespace v8::internal;
  12 using namespace v8::internal::compiler;
  13
  14 TEST(CompareWrapper) {
  15   // Who tests the testers?
  16   // If CompareWrapper is broken, then test expectations will be broken.
  17   RawMachineAssemblerTester<int32_t> m;
  18   CompareWrapper wWord32Equal(IrOpcode::kWord32Equal);
  19   CompareWrapper wInt32LessThan(IrOpcode::kInt32LessThan);
  20   CompareWrapper wInt32LessThanOrEqual(IrOpcode::kInt32LessThanOrEqual);
  21   CompareWrapper wUint32LessThan(IrOpcode::kUint32LessThan);
  22   CompareWrapper wUint32LessThanOrEqual(IrOpcode::kUint32LessThanOrEqual);
  23
  24   {
  25     FOR_INT32_INPUTS(pl) {
  26       FOR_INT32_INPUTS(pr) {
  27         int32_t a = *pl;
  28         int32_t b = *pr;
  29         CHECK_EQ(a == b, wWord32Equal.Int32Compare(a, b));
  30         CHECK_EQ(a < b, wInt32LessThan.Int32Compare(a, b));
  31         CHECK_EQ(a <= b, wInt32LessThanOrEqual.Int32Compare(a, b));
  32       }
  33     }
  34   }
  35
  36   {
  37     FOR_UINT32_INPUTS(pl) {
  38       FOR_UINT32_INPUTS(pr) {
  39         uint32_t a = *pl;
  40         uint32_t b = *pr;
  41         CHECK_EQ(a == b, wWord32Equal.Int32Compare(a, b));
  42         CHECK_EQ(a < b, wUint32LessThan.Int32Compare(a, b));
  43         CHECK_EQ(a <= b, wUint32LessThanOrEqual.Int32Compare(a, b));
  44       }
  45     }
  46   }
  47
  48   CHECK_EQ(true, wWord32Equal.Int32Compare(0, 0));
  49   CHECK_EQ(true, wWord32Equal.Int32Compare(257, 257));
  50   CHECK_EQ(true, wWord32Equal.Int32Compare(65539, 65539));
  51   CHECK_EQ(true, wWord32Equal.Int32Compare(-1, -1));
  52   CHECK_EQ(true, wWord32Equal.Int32Compare(0xffffffff, 0xffffffff));
  53
  54   CHECK_EQ(false, wWord32Equal.Int32Compare(0, 1));
  55   CHECK_EQ(false, wWord32Equal.Int32Compare(257, 256));
  56   CHECK_EQ(false, wWord32Equal.Int32Compare(65539, 65537));
  57   CHECK_EQ(false, wWord32Equal.Int32Compare(-1, -2));
  58   CHECK_EQ(false, wWord32Equal.Int32Compare(0xffffffff, 0xfffffffe));
  59
  60   CHECK_EQ(false, wInt32LessThan.Int32Compare(0, 0));
  61   CHECK_EQ(false, wInt32LessThan.Int32Compare(357, 357));
  62   CHECK_EQ(false, wInt32LessThan.Int32Compare(75539, 75539));
  63   CHECK_EQ(false, wInt32LessThan.Int32Compare(-1, -1));
  64   CHECK_EQ(false, wInt32LessThan.Int32Compare(0xffffffff, 0xffffffff));
  65
  66   CHECK_EQ(true, wInt32LessThan.Int32Compare(0, 1));
  67   CHECK_EQ(true, wInt32LessThan.Int32Compare(456, 457));
  68   CHECK_EQ(true, wInt32LessThan.Int32Compare(85537, 85539));
  69   CHECK_EQ(true, wInt32LessThan.Int32Compare(-2, -1));
  70   CHECK_EQ(true, wInt32LessThan.Int32Compare(0xfffffffe, 0xffffffff));
  71
  72   CHECK_EQ(false, wInt32LessThan.Int32Compare(1, 0));
  73   CHECK_EQ(false, wInt32LessThan.Int32Compare(457, 456));
  74   CHECK_EQ(false, wInt32LessThan.Int32Compare(85539, 85537));
  75   CHECK_EQ(false, wInt32LessThan.Int32Compare(-1, -2));
  76   CHECK_EQ(false, wInt32LessThan.Int32Compare(0xffffffff, 0xfffffffe));
  77
  78   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(0, 0));
  79   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(357, 357));
  80   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(75539, 75539));
  81   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(-1, -1));
  82   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(0xffffffff, 0xffffffff));
  83
  84   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(0, 1));
  85   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(456, 457));
  86   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(85537, 85539));
  87   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(-2, -1));
  88   CHECK_EQ(true, wInt32LessThanOrEqual.Int32Compare(0xfffffffe, 0xffffffff));
  89
  90   CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(1, 0));
  91   CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(457, 456));
  92   CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(85539, 85537));
  93   CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(-1, -2));
  94   CHECK_EQ(false, wInt32LessThanOrEqual.Int32Compare(0xffffffff, 0xfffffffe));
  95
  96   // Unsigned comparisons.
  97   CHECK_EQ(false, wUint32LessThan.Int32Compare(0, 0));
  98   CHECK_EQ(false, wUint32LessThan.Int32Compare(357, 357));
  99   CHECK_EQ(false, wUint32LessThan.Int32Compare(75539, 75539));
 100   CHECK_EQ(false, wUint32LessThan.Int32Compare(-1, -1));
 101   CHECK_EQ(false, wUint32LessThan.Int32Compare(0xffffffff, 0xffffffff));
 102   CHECK_EQ(false, wUint32LessThan.Int32Compare(0xffffffff, 0));
 103   CHECK_EQ(false, wUint32LessThan.Int32Compare(-2999, 0));
 104
 105   CHECK_EQ(true, wUint32LessThan.Int32Compare(0, 1));
 106   CHECK_EQ(true, wUint32LessThan.Int32Compare(456, 457));
 107   CHECK_EQ(true, wUint32LessThan.Int32Compare(85537, 85539));
 108   CHECK_EQ(true, wUint32LessThan.Int32Compare(-11, -10));
 109   CHECK_EQ(true, wUint32LessThan.Int32Compare(0xfffffffe, 0xffffffff));
 110   CHECK_EQ(true, wUint32LessThan.Int32Compare(0, 0xffffffff));
 111   CHECK_EQ(true, wUint32LessThan.Int32Compare(0, -2996));
 112
 113   CHECK_EQ(false, wUint32LessThan.Int32Compare(1, 0));
 114   CHECK_EQ(false, wUint32LessThan.Int32Compare(457, 456));
 115   CHECK_EQ(false, wUint32LessThan.Int32Compare(85539, 85537));
 116   CHECK_EQ(false, wUint32LessThan.Int32Compare(-10, -21));
 117   CHECK_EQ(false, wUint32LessThan.Int32Compare(0xffffffff, 0xfffffffe));
 118
 119   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0, 0));
 120   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(357, 357));
 121   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(75539, 75539));
 122   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(-1, -1));
 123   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0xffffffff, 0xffffffff));
 124
 125   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0, 1));
 126   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(456, 457));
 127   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(85537, 85539));
 128   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(-300, -299));
 129   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(-300, -300));
 130   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0xfffffffe, 0xffffffff));
 131   CHECK_EQ(true, wUint32LessThanOrEqual.Int32Compare(0, -2995));
 132
 133   CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(1, 0));
 134   CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(457, 456));
 135   CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(85539, 85537));
 136   CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(-130, -170));
 137   CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(0xffffffff, 0xfffffffe));
 138   CHECK_EQ(false, wUint32LessThanOrEqual.Int32Compare(-2997, 0));
 139
 140   CompareWrapper wFloat64Equal(IrOpcode::kFloat64Equal);
 141   CompareWrapper wFloat64LessThan(IrOpcode::kFloat64LessThan);
 142   CompareWrapper wFloat64LessThanOrEqual(IrOpcode::kFloat64LessThanOrEqual);
 143
 144   // Check NaN handling.
 145   double nan = v8::base::OS::nan_value();
 146   double inf = V8_INFINITY;
 147   CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, 0.0));
 148   CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, 1.0));
 149   CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, inf));
 150   CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, -inf));
 151   CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, nan));
 152
 153   CHECK_EQ(false, wFloat64Equal.Float64Compare(0.0, nan));
 154   CHECK_EQ(false, wFloat64Equal.Float64Compare(1.0, nan));
 155   CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, nan));
 156   CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, nan));
 157   CHECK_EQ(false, wFloat64Equal.Float64Compare(nan, nan));
 158
 159   CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, 0.0));
 160   CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, 1.0));
 161   CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, inf));
 162   CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, -inf));
 163   CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, nan));
 164
 165   CHECK_EQ(false, wFloat64LessThan.Float64Compare(0.0, nan));
 166   CHECK_EQ(false, wFloat64LessThan.Float64Compare(1.0, nan));
 167   CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, nan));
 168   CHECK_EQ(false, wFloat64LessThan.Float64Compare(-inf, nan));
 169   CHECK_EQ(false, wFloat64LessThan.Float64Compare(nan, nan));
 170
 171   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, 0.0));
 172   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, 1.0));
 173   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, inf));
 174   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, -inf));
 175   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, nan));
 176
 177   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(0.0, nan));
 178   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(1.0, nan));
 179   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, nan));
 180   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(-inf, nan));
 181   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(nan, nan));
 182
 183   // Check inf handling.
 184   CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, 0.0));
 185   CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, 1.0));
 186   CHECK_EQ(true, wFloat64Equal.Float64Compare(inf, inf));
 187   CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, -inf));
 188
 189   CHECK_EQ(false, wFloat64Equal.Float64Compare(0.0, inf));
 190   CHECK_EQ(false, wFloat64Equal.Float64Compare(1.0, inf));
 191   CHECK_EQ(true, wFloat64Equal.Float64Compare(inf, inf));
 192   CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, inf));
 193
 194   CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, 0.0));
 195   CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, 1.0));
 196   CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, inf));
 197   CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, -inf));
 198
 199   CHECK_EQ(true, wFloat64LessThan.Float64Compare(0.0, inf));
 200   CHECK_EQ(true, wFloat64LessThan.Float64Compare(1.0, inf));
 201   CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, inf));
 202   CHECK_EQ(true, wFloat64LessThan.Float64Compare(-inf, inf));
 203
 204   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, 0.0));
 205   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, 1.0));
 206   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(inf, inf));
 207   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, -inf));
 208
 209   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(0.0, inf));
 210   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(1.0, inf));
 211   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(inf, inf));
 212   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, inf));
 213
 214   // Check -inf handling.
 215   CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, 0.0));
 216   CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, 1.0));
 217   CHECK_EQ(false, wFloat64Equal.Float64Compare(-inf, inf));
 218   CHECK_EQ(true, wFloat64Equal.Float64Compare(-inf, -inf));
 219
 220   CHECK_EQ(false, wFloat64Equal.Float64Compare(0.0, -inf));
 221   CHECK_EQ(false, wFloat64Equal.Float64Compare(1.0, -inf));
 222   CHECK_EQ(false, wFloat64Equal.Float64Compare(inf, -inf));
 223   CHECK_EQ(true, wFloat64Equal.Float64Compare(-inf, -inf));
 224
 225   CHECK_EQ(true, wFloat64LessThan.Float64Compare(-inf, 0.0));
 226   CHECK_EQ(true, wFloat64LessThan.Float64Compare(-inf, 1.0));
 227   CHECK_EQ(true, wFloat64LessThan.Float64Compare(-inf, inf));
 228   CHECK_EQ(false, wFloat64LessThan.Float64Compare(-inf, -inf));
 229
 230   CHECK_EQ(false, wFloat64LessThan.Float64Compare(0.0, -inf));
 231   CHECK_EQ(false, wFloat64LessThan.Float64Compare(1.0, -inf));
 232   CHECK_EQ(false, wFloat64LessThan.Float64Compare(inf, -inf));
 233   CHECK_EQ(false, wFloat64LessThan.Float64Compare(-inf, -inf));
 234
 235   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, 0.0));
 236   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, 1.0));
 237   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, inf));
 238   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, -inf));
 239
 240   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(0.0, -inf));
 241   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(1.0, -inf));
 242   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(inf, -inf));
 243   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-inf, -inf));
 244
 245   // Check basic values.
 246   CHECK_EQ(true, wFloat64Equal.Float64Compare(0, 0));
 247   CHECK_EQ(true, wFloat64Equal.Float64Compare(257.1, 257.1));
 248   CHECK_EQ(true, wFloat64Equal.Float64Compare(65539.1, 65539.1));
 249   CHECK_EQ(true, wFloat64Equal.Float64Compare(-1.1, -1.1));
 250
 251   CHECK_EQ(false, wFloat64Equal.Float64Compare(0, 1));
 252   CHECK_EQ(false, wFloat64Equal.Float64Compare(257.2, 256.2));
 253   CHECK_EQ(false, wFloat64Equal.Float64Compare(65539.2, 65537.2));
 254   CHECK_EQ(false, wFloat64Equal.Float64Compare(-1.2, -2.2));
 255
 256   CHECK_EQ(false, wFloat64LessThan.Float64Compare(0, 0));
 257   CHECK_EQ(false, wFloat64LessThan.Float64Compare(357.3, 357.3));
 258   CHECK_EQ(false, wFloat64LessThan.Float64Compare(75539.3, 75539.3));
 259   CHECK_EQ(false, wFloat64LessThan.Float64Compare(-1.3, -1.3));
 260
 261   CHECK_EQ(true, wFloat64LessThan.Float64Compare(0, 1));
 262   CHECK_EQ(true, wFloat64LessThan.Float64Compare(456.4, 457.4));
 263   CHECK_EQ(true, wFloat64LessThan.Float64Compare(85537.4, 85539.4));
 264   CHECK_EQ(true, wFloat64LessThan.Float64Compare(-2.4, -1.4));
 265
 266   CHECK_EQ(false, wFloat64LessThan.Float64Compare(1, 0));
 267   CHECK_EQ(false, wFloat64LessThan.Float64Compare(457.5, 456.5));
 268   CHECK_EQ(false, wFloat64LessThan.Float64Compare(85539.5, 85537.5));
 269   CHECK_EQ(false, wFloat64LessThan.Float64Compare(-1.5, -2.5));
 270
 271   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(0, 0));
 272   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(357.6, 357.6));
 273   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(75539.6, 75539.6));
 274   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-1.6, -1.6));
 275
 276   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(0, 1));
 277   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(456.7, 457.7));
 278   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(85537.7, 85539.7));
 279   CHECK_EQ(true, wFloat64LessThanOrEqual.Float64Compare(-2.7, -1.7));
 280
 281   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(1, 0));
 282   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(457.8, 456.8));
 283   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(85539.8, 85537.8));
 284   CHECK_EQ(false, wFloat64LessThanOrEqual.Float64Compare(-1.8, -2.8));
 285 }
 286
 287
 288 void Int32BinopInputShapeTester::TestAllInputShapes() {
 289   std::vector<int32_t> inputs = ValueHelper::int32_vector();
 290   int num_int_inputs = static_cast<int>(inputs.size());
 291   if (num_int_inputs > 16) num_int_inputs = 16;  // limit to 16 inputs
 292
 293   for (int i = -2; i < num_int_inputs; i++) {    // for all left shapes
 294     for (int j = -2; j < num_int_inputs; j++) {  // for all right shapes
 295       if (i >= 0 && j >= 0) break;               // No constant/constant combos
 296       RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
 297       Node* p0 = m.Parameter(0);
 298       Node* p1 = m.Parameter(1);
 299       Node* n0;
 300       Node* n1;
 301
 302       // left = Parameter | Load | Constant
 303       if (i == -2) {
 304         n0 = p0;
 305       } else if (i == -1) {
 306         n0 = m.LoadFromPointer(&input_a, kMachInt32);
 307       } else {
 308         n0 = m.Int32Constant(inputs[i]);
 309       }
 310
 311       // right = Parameter | Load | Constant
 312       if (j == -2) {
 313         n1 = p1;
 314       } else if (j == -1) {
 315         n1 = m.LoadFromPointer(&input_b, kMachInt32);
 316       } else {
 317         n1 = m.Int32Constant(inputs[j]);
 318       }
 319
 320       gen->gen(&m, n0, n1);
 321
 322       if (false) printf("Int32BinopInputShapeTester i=%d, j=%d\n", i, j);
 323       if (i >= 0) {
 324         input_a = inputs[i];
 325         RunRight(&m);
 326       } else if (j >= 0) {
 327         input_b = inputs[j];
 328         RunLeft(&m);
 329       } else {
 330         Run(&m);
 331       }
 332     }
 333   }
 334 }
 335
 336
 337 void Int32BinopInputShapeTester::Run(RawMachineAssemblerTester<int32_t>* m) {
 338   FOR_INT32_INPUTS(pl) {
 339     FOR_INT32_INPUTS(pr) {
 340       input_a = *pl;
 341       input_b = *pr;
 342       int32_t expect = gen->expected(input_a, input_b);
 343       if (false) printf("  cmp(a=%d, b=%d) ?== %d\n", input_a, input_b, expect);
 344       CHECK_EQ(expect, m->Call(input_a, input_b));
 345     }
 346   }
 347 }
 348
 349
 350 void Int32BinopInputShapeTester::RunLeft(
 351     RawMachineAssemblerTester<int32_t>* m) {
 352   FOR_UINT32_INPUTS(i) {
 353     input_a = *i;
 354     int32_t expect = gen->expected(input_a, input_b);
 355     if (false) printf("  cmp(a=%d, b=%d) ?== %d\n", input_a, input_b, expect);
 356     CHECK_EQ(expect, m->Call(input_a, input_b));
 357   }
 358 }
 359
 360
 361 void Int32BinopInputShapeTester::RunRight(
 362     RawMachineAssemblerTester<int32_t>* m) {
 363   FOR_UINT32_INPUTS(i) {
 364     input_b = *i;
 365     int32_t expect = gen->expected(input_a, input_b);
 366     if (false) printf("  cmp(a=%d, b=%d) ?== %d\n", input_a, input_b, expect);
 367     CHECK_EQ(expect, m->Call(input_a, input_b));
 368   }
 369 }
 370
 371
 372 #if V8_TURBOFAN_TARGET
 373
 374 TEST(ParametersEqual) {
 375   RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
 376   Node* p1 = m.Parameter(1);
 377   CHECK_NE(NULL, p1);
 378   Node* p0 = m.Parameter(0);
 379   CHECK_NE(NULL, p0);
 380   CHECK_EQ(p0, m.Parameter(0));
 381   CHECK_EQ(p1, m.Parameter(1));
 382 }
 383
 384
 385 void RunSmiConstant(int32_t v) {
 386 // TODO(dcarney): on x64 Smis are generated with the SmiConstantRegister
 387 #if !V8_TARGET_ARCH_X64
 388   if (Smi::IsValid(v)) {
 389     RawMachineAssemblerTester<Object*> m;
 390     m.Return(m.NumberConstant(v));
 391     CHECK_EQ(Smi::FromInt(v), m.Call());
 392   }
 393 #endif
 394 }
 395
 396
 397 void RunNumberConstant(double v) {
 398   RawMachineAssemblerTester<Object*> m;
 399 #if V8_TARGET_ARCH_X64
 400   // TODO(dcarney): on x64 Smis are generated with the SmiConstantRegister
 401   Handle<Object> number = m.isolate()->factory()->NewNumber(v);
 402   if (number->IsSmi()) return;
 403 #endif
 404   m.Return(m.NumberConstant(v));
 405   Object* result = m.Call();
 406   m.CheckNumber(v, result);
 407 }
 408
 409
 410 TEST(RunEmpty) {
 411   RawMachineAssemblerTester<int32_t> m;
 412   m.Return(m.Int32Constant(0));
 413   CHECK_EQ(0, m.Call());
 414 }
 415
 416
 417 TEST(RunInt32Constants) {
 418   FOR_INT32_INPUTS(i) {
 419     RawMachineAssemblerTester<int32_t> m;
 420     m.Return(m.Int32Constant(*i));
 421     CHECK_EQ(*i, m.Call());
 422   }
 423 }
 424
 425
 426 TEST(RunSmiConstants) {
 427   for (int32_t i = 1; i < Smi::kMaxValue && i != 0; i = i << 1) {
 428     RunSmiConstant(i);
 429     RunSmiConstant(3 * i);
 430     RunSmiConstant(5 * i);
 431     RunSmiConstant(-i);
 432     RunSmiConstant(i | 1);
 433     RunSmiConstant(i | 3);
 434   }
 435   RunSmiConstant(Smi::kMaxValue);
 436   RunSmiConstant(Smi::kMaxValue - 1);
 437   RunSmiConstant(Smi::kMinValue);
 438   RunSmiConstant(Smi::kMinValue + 1);
 439
 440   FOR_INT32_INPUTS(i) { RunSmiConstant(*i); }
 441 }
 442
 443
 444 TEST(RunNumberConstants) {
 445   {
 446     FOR_FLOAT64_INPUTS(i) { RunNumberConstant(*i); }
 447   }
 448   {
 449     FOR_INT32_INPUTS(i) { RunNumberConstant(*i); }
 450   }
 451
 452   for (int32_t i = 1; i < Smi::kMaxValue && i != 0; i = i << 1) {
 453     RunNumberConstant(i);
 454     RunNumberConstant(-i);
 455     RunNumberConstant(i | 1);
 456     RunNumberConstant(i | 3);
 457   }
 458   RunNumberConstant(Smi::kMaxValue);
 459   RunNumberConstant(Smi::kMaxValue - 1);
 460   RunNumberConstant(Smi::kMinValue);
 461   RunNumberConstant(Smi::kMinValue + 1);
 462 }
 463
 464
 465 TEST(RunEmptyString) {
 466   RawMachineAssemblerTester<Object*> m;
 467   m.Return(m.StringConstant("empty"));
 468   m.CheckString("empty", m.Call());
 469 }
 470
 471
 472 TEST(RunHeapConstant) {
 473   RawMachineAssemblerTester<Object*> m;
 474   m.Return(m.StringConstant("empty"));
 475   m.CheckString("empty", m.Call());
 476 }
 477
 478
 479 TEST(RunHeapNumberConstant) {
 480   RawMachineAssemblerTester<Object*> m;
 481   Handle<Object> number = m.isolate()->factory()->NewHeapNumber(100.5);
 482   m.Return(m.HeapConstant(number));
 483   Object* result = m.Call();
 484   CHECK_EQ(result, *number);
 485 }
 486
 487
 488 TEST(RunParam1) {
 489   RawMachineAssemblerTester<int32_t> m(kMachInt32);
 490   m.Return(m.Parameter(0));
 491
 492   FOR_INT32_INPUTS(i) {
 493     int32_t result = m.Call(*i);
 494     CHECK_EQ(*i, result);
 495   }
 496 }
 497
 498
 499 TEST(RunParam2_1) {
 500   RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
 501   Node* p0 = m.Parameter(0);
 502   Node* p1 = m.Parameter(1);
 503   m.Return(p0);
 504   USE(p1);
 505
 506   FOR_INT32_INPUTS(i) {
 507     int32_t result = m.Call(*i, -9999);
 508     CHECK_EQ(*i, result);
 509   }
 510 }
 511
 512
 513 TEST(RunParam2_2) {
 514   RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
 515   Node* p0 = m.Parameter(0);
 516   Node* p1 = m.Parameter(1);
 517   m.Return(p1);
 518   USE(p0);
 519
 520   FOR_INT32_INPUTS(i) {
 521     int32_t result = m.Call(-7777, *i);
 522     CHECK_EQ(*i, result);
 523   }
 524 }
 525
 526
 527 TEST(RunParam3) {
 528   for (int i = 0; i < 3; i++) {
 529     RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
 530     Node* nodes[] = {m.Parameter(0), m.Parameter(1), m.Parameter(2)};
 531     m.Return(nodes[i]);
 532
 533     int p[] = {-99, -77, -88};
 534     FOR_INT32_INPUTS(j) {
 535       p[i] = *j;
 536       int32_t result = m.Call(p[0], p[1], p[2]);
 537       CHECK_EQ(*j, result);
 538     }
 539   }
 540 }
 541
 542
 543 TEST(RunBinopTester) {
 544   {
 545     RawMachineAssemblerTester<int32_t> m;
 546     Int32BinopTester bt(&m);
 547     bt.AddReturn(bt.param0);
 548
 549     FOR_INT32_INPUTS(i) { CHECK_EQ(*i, bt.call(*i, 777)); }
 550   }
 551
 552   {
 553     RawMachineAssemblerTester<int32_t> m;
 554     Int32BinopTester bt(&m);
 555     bt.AddReturn(bt.param1);
 556
 557     FOR_INT32_INPUTS(i) { CHECK_EQ(*i, bt.call(666, *i)); }
 558   }
 559
 560   {
 561     RawMachineAssemblerTester<int32_t> m;
 562     Float64BinopTester bt(&m);
 563     bt.AddReturn(bt.param0);
 564
 565     FOR_FLOAT64_INPUTS(i) { CHECK_EQ(*i, bt.call(*i, 9.0)); }
 566   }
 567
 568   {
 569     RawMachineAssemblerTester<int32_t> m;
 570     Float64BinopTester bt(&m);
 571     bt.AddReturn(bt.param1);
 572
 573     FOR_FLOAT64_INPUTS(i) { CHECK_EQ(*i, bt.call(-11.25, *i)); }
 574   }
 575 }
 576
 577 #endif  // V8_TURBOFAN_TARGET