src/runtime.js

   1 // Copyright 2006-2008 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 // This files contains runtime support implemented in JavaScript.
   6
   7 // CAUTION: Some of the functions specified in this file are called
   8 // directly from compiled code. These are the functions with names in
   9 // ALL CAPS. The compiled code passes the first argument in 'this'.
  10
  11
  12 // The following declarations are shared with other native JS files.
  13 // They are all declared at this one spot to avoid redeclaration errors.
  14 var $defaultNumber;
  15 var $defaultString;
  16 var $NaN;
  17 var $nonNumberToNumber;
  18 var $nonStringToString;
  19 var $sameValue;
  20 var $sameValueZero;
  21 var $toInteger;
  22 var $toLength;
  23 var $toName;
  24 var $toNumber;
  25 var $toPositiveInteger;
  26 var $toPrimitive;
  27 var $toString;
  28
  29 (function(global, utils) {
  30
  31 %CheckIsBootstrapping();
  32
  33 var GlobalArray = global.Array;
  34 var GlobalBoolean = global.Boolean;
  35 var GlobalString = global.String;
  36 var GlobalNumber = global.Number;
  37
  38 // ----------------------------------------------------------------------------
  39
  40 /* -----------------------------------
  41 - - -   C o m p a r i s o n   - - -
  42 -----------------------------------
  43 */
  44
  45 // ECMA-262 Section 11.9.3.
  46 function EQUALS(y) {
  47   if (IS_STRING(this) && IS_STRING(y)) return %StringEquals(this, y);
  48   var x = this;
  49
  50   while (true) {
  51     if (IS_NUMBER(x)) {
  52       while (true) {
  53         if (IS_NUMBER(y)) return %NumberEquals(x, y);
  54         if (IS_NULL_OR_UNDEFINED(y)) return 1;  // not equal
  55         if (!IS_SPEC_OBJECT(y)) {
  56           if (IS_SYMBOL(y) || IS_SIMD_VALUE(y)) return 1;  // not equal
  57           // String or boolean.
  58           return %NumberEquals(x, %to_number_fun(y));
  59         }
  60         y = %to_primitive(y, NO_HINT);
  61       }
  62     } else if (IS_STRING(x)) {
  63       while (true) {
  64         if (IS_STRING(y)) return %StringEquals(x, y);
  65         if (IS_NUMBER(y)) return %NumberEquals(%to_number_fun(x), y);
  66         if (IS_BOOLEAN(y)) {
  67           return %NumberEquals(%to_number_fun(x), %to_number_fun(y));
  68         }
  69         if (IS_NULL_OR_UNDEFINED(y)) return 1;  // not equal
  70         if (IS_SYMBOL(y) || IS_SIMD_VALUE(y)) return 1;  // not equal
  71         y = %to_primitive(y, NO_HINT);
  72       }
  73     } else if (IS_SYMBOL(x)) {
  74       if (IS_SYMBOL(y)) return %_ObjectEquals(x, y) ? 0 : 1;
  75       return 1; // not equal
  76     } else if (IS_BOOLEAN(x)) {
  77       if (IS_BOOLEAN(y)) return %_ObjectEquals(x, y) ? 0 : 1;
  78       if (IS_NULL_OR_UNDEFINED(y)) return 1;
  79       if (IS_NUMBER(y)) return %NumberEquals(%to_number_fun(x), y);
  80       if (IS_STRING(y)) {
  81         return %NumberEquals(%to_number_fun(x), %to_number_fun(y));
  82       }
  83       if (IS_SYMBOL(y) || IS_SIMD_VALUE(y)) return 1;  // not equal
  84       // y is object.
  85       x = %to_number_fun(x);
  86       y = %to_primitive(y, NO_HINT);
  87     } else if (IS_NULL_OR_UNDEFINED(x)) {
  88       return IS_NULL_OR_UNDEFINED(y) ? 0 : 1;
  89     } else if (IS_SIMD_VALUE(x)) {
  90       if (!IS_SIMD_VALUE(y)) return 1;  // not equal
  91        return %SimdEquals(x, y);
  92     } else {
  93       // x is an object.
  94       if (IS_SPEC_OBJECT(y)) return %_ObjectEquals(x, y) ? 0 : 1;
  95       if (IS_NULL_OR_UNDEFINED(y)) return 1;  // not equal
  96       if (IS_BOOLEAN(y)) {
  97         y = %to_number_fun(y);
  98       } else if (IS_SYMBOL(y) || IS_SIMD_VALUE(y)) {
  99         return 1;  // not equal
 100       }
 101       x = %to_primitive(x, NO_HINT);
 102     }
 103   }
 104 }
 105
 106
 107 // ECMA-262, section 11.8.5, page 53. The 'ncr' parameter is used as
 108 // the result when either (or both) the operands are NaN.
 109 function COMPARE(x, ncr) {
 110   var left;
 111   var right;
 112   // Fast cases for string, numbers and undefined compares.
 113   if (IS_STRING(this)) {
 114     if (IS_STRING(x)) return %_StringCompare(this, x);
 115     if (IS_UNDEFINED(x)) return ncr;
 116     left = this;
 117   } else if (IS_NUMBER(this)) {
 118     if (IS_NUMBER(x)) return %NumberCompare(this, x, ncr);
 119     if (IS_UNDEFINED(x)) return ncr;
 120     left = this;
 121   } else if (IS_UNDEFINED(this)) {
 122     if (!IS_UNDEFINED(x)) {
 123       %to_primitive(x, NUMBER_HINT);
 124     }
 125     return ncr;
 126   } else if (IS_UNDEFINED(x)) {
 127     %to_primitive(this, NUMBER_HINT);
 128     return ncr;
 129   } else {
 130     left = %to_primitive(this, NUMBER_HINT);
 131   }
 132
 133   right = %to_primitive(x, NUMBER_HINT);
 134   if (IS_STRING(left) && IS_STRING(right)) {
 135     return %_StringCompare(left, right);
 136   } else {
 137     var left_number = %to_number_fun(left);
 138     var right_number = %to_number_fun(right);
 139     if (NUMBER_IS_NAN(left_number) || NUMBER_IS_NAN(right_number)) return ncr;
 140     return %NumberCompare(left_number, right_number, ncr);
 141   }
 142 }
 143
 144 // Strong mode COMPARE throws if an implicit conversion would be performed
 145 function COMPARE_STRONG(x, ncr) {
 146   if (IS_STRING(this) && IS_STRING(x)) return %_StringCompare(this, x);
 147   if (IS_NUMBER(this) && IS_NUMBER(x)) return %NumberCompare(this, x, ncr);
 148
 149   throw %make_type_error(kStrongImplicitConversion);
 150 }
 151
 152
 153
 154 /* -----------------------------------
 155    - - -   A r i t h m e t i c   - - -
 156    -----------------------------------
 157 */
 158
 159 // ECMA-262, section 11.6.1, page 50.
 160 function ADD(x) {
 161   // Fast case: Check for number operands and do the addition.
 162   if (IS_NUMBER(this) && IS_NUMBER(x)) return %NumberAdd(this, x);
 163   if (IS_STRING(this) && IS_STRING(x)) return %_StringAdd(this, x);
 164
 165   // Default implementation.
 166   var a = %to_primitive(this, NO_HINT);
 167   var b = %to_primitive(x, NO_HINT);
 168
 169   if (IS_STRING(a)) {
 170     return %_StringAdd(a, %to_string_fun(b));
 171   } else if (IS_STRING(b)) {
 172     return %_StringAdd(%non_string_to_string(a), b);
 173   } else {
 174     return %NumberAdd(%to_number_fun(a), %to_number_fun(b));
 175   }
 176 }
 177
 178
 179 // Strong mode ADD throws if an implicit conversion would be performed
 180 function ADD_STRONG(x) {
 181   if (IS_NUMBER(this) && IS_NUMBER(x)) return %NumberAdd(this, x);
 182   if (IS_STRING(this) && IS_STRING(x)) return %_StringAdd(this, x);
 183
 184   throw %make_type_error(kStrongImplicitConversion);
 185 }
 186
 187
 188 // Left operand (this) is already a string.
 189 function STRING_ADD_LEFT(y) {
 190   if (!IS_STRING(y)) {
 191     if (IS_STRING_WRAPPER(y) && %_IsStringWrapperSafeForDefaultValueOf(y)) {
 192       y = %_ValueOf(y);
 193     } else {
 194       y = IS_NUMBER(y)
 195           ? %_NumberToString(y)
 196           : %to_string_fun(%to_primitive(y, NO_HINT));
 197     }
 198   }
 199   return %_StringAdd(this, y);
 200 }
 201
 202
 203 // Right operand (y) is already a string.
 204 function STRING_ADD_RIGHT(y) {
 205   var x = this;
 206   if (!IS_STRING(x)) {
 207     if (IS_STRING_WRAPPER(x) && %_IsStringWrapperSafeForDefaultValueOf(x)) {
 208       x = %_ValueOf(x);
 209     } else {
 210       x = IS_NUMBER(x)
 211           ? %_NumberToString(x)
 212           : %to_string_fun(%to_primitive(x, NO_HINT));
 213     }
 214   }
 215   return %_StringAdd(x, y);
 216 }
 217
 218
 219 // ECMA-262, section 11.6.2, page 50.
 220 function SUB(y) {
 221   var x = IS_NUMBER(this) ? this : %non_number_to_number(this);
 222   if (!IS_NUMBER(y)) y = %non_number_to_number(y);
 223   return %NumberSub(x, y);
 224 }
 225
 226
 227 // Strong mode SUB throws if an implicit conversion would be performed
 228 function SUB_STRONG(y) {
 229   if (IS_NUMBER(this) && IS_NUMBER(y)) {
 230     return %NumberSub(this, y);
 231   }
 232   throw %make_type_error(kStrongImplicitConversion);
 233 }
 234
 235
 236 // ECMA-262, section 11.5.1, page 48.
 237 function MUL(y) {
 238   var x = IS_NUMBER(this) ? this : %non_number_to_number(this);
 239   if (!IS_NUMBER(y)) y = %non_number_to_number(y);
 240   return %NumberMul(x, y);
 241 }
 242
 243
 244 // Strong mode MUL throws if an implicit conversion would be performed
 245 function MUL_STRONG(y) {
 246   if (IS_NUMBER(this) && IS_NUMBER(y)) {
 247     return %NumberMul(this, y);
 248   }
 249   throw %make_type_error(kStrongImplicitConversion);
 250 }
 251
 252
 253 // ECMA-262, section 11.5.2, page 49.
 254 function DIV(y) {
 255   var x = IS_NUMBER(this) ? this : %non_number_to_number(this);
 256   if (!IS_NUMBER(y)) y = %non_number_to_number(y);
 257   return %NumberDiv(x, y);
 258 }
 259
 260
 261 // Strong mode DIV throws if an implicit conversion would be performed
 262 function DIV_STRONG(y) {
 263   if (IS_NUMBER(this) && IS_NUMBER(y)) {
 264     return %NumberDiv(this, y);
 265   }
 266   throw %make_type_error(kStrongImplicitConversion);
 267 }
 268
 269
 270 // ECMA-262, section 11.5.3, page 49.
 271 function MOD(y) {
 272   var x = IS_NUMBER(this) ? this : %non_number_to_number(this);
 273   if (!IS_NUMBER(y)) y = %non_number_to_number(y);
 274   return %NumberMod(x, y);
 275 }
 276
 277
 278 // Strong mode MOD throws if an implicit conversion would be performed
 279 function MOD_STRONG(y) {
 280   if (IS_NUMBER(this) && IS_NUMBER(y)) {
 281     return %NumberMod(this, y);
 282   }
 283   throw %make_type_error(kStrongImplicitConversion);
 284 }
 285
 286
 287 /* -------------------------------------------
 288    - - -   B i t   o p e r a t i o n s   - - -
 289    -------------------------------------------
 290 */
 291
 292 // ECMA-262, section 11.10, page 57.
 293 function BIT_OR(y) {
 294   var x = IS_NUMBER(this) ? this : %non_number_to_number(this);
 295   if (!IS_NUMBER(y)) y = %non_number_to_number(y);
 296   return %NumberOr(x, y);
 297 }
 298
 299
 300 // Strong mode BIT_OR throws if an implicit conversion would be performed
 301 function BIT_OR_STRONG(y) {
 302   if (IS_NUMBER(this) && IS_NUMBER(y)) {
 303     return %NumberOr(this, y);
 304   }
 305   throw %make_type_error(kStrongImplicitConversion);
 306 }
 307
 308
 309 // ECMA-262, section 11.10, page 57.
 310 function BIT_AND(y) {
 311   var x;
 312   if (IS_NUMBER(this)) {
 313     x = this;
 314     if (!IS_NUMBER(y)) y = %non_number_to_number(y);
 315   } else {
 316     x = %non_number_to_number(this);
 317     // Make sure to convert the right operand to a number before
 318     // bailing out in the fast case, but after converting the
 319     // left operand. This ensures that valueOf methods on the right
 320     // operand are always executed.
 321     if (!IS_NUMBER(y)) y = %non_number_to_number(y);
 322     // Optimize for the case where we end up AND'ing a value
 323     // that doesn't convert to a number. This is common in
 324     // certain benchmarks.
 325     if (NUMBER_IS_NAN(x)) return 0;
 326   }
 327   return %NumberAnd(x, y);
 328 }
 329
 330
 331 // Strong mode BIT_AND throws if an implicit conversion would be performed
 332 function BIT_AND_STRONG(y) {
 333   if (IS_NUMBER(this) && IS_NUMBER(y)) {
 334     return %NumberAnd(this, y);
 335   }
 336   throw %make_type_error(kStrongImplicitConversion);
 337 }
 338
 339
 340 // ECMA-262, section 11.10, page 57.
 341 function BIT_XOR(y) {
 342   var x = IS_NUMBER(this) ? this : %non_number_to_number(this);
 343   if (!IS_NUMBER(y)) y = %non_number_to_number(y);
 344   return %NumberXor(x, y);
 345 }
 346
 347
 348 // Strong mode BIT_XOR throws if an implicit conversion would be performed
 349 function BIT_XOR_STRONG(y) {
 350   if (IS_NUMBER(this) && IS_NUMBER(y)) {
 351     return %NumberXor(this, y);
 352   }
 353   throw %make_type_error(kStrongImplicitConversion);
 354 }
 355
 356
 357 // ECMA-262, section 11.7.1, page 51.
 358 function SHL(y) {
 359   var x = IS_NUMBER(this) ? this : %non_number_to_number(this);
 360   if (!IS_NUMBER(y)) y = %non_number_to_number(y);
 361   return %NumberShl(x, y);
 362 }
 363
 364
 365 // Strong mode SHL throws if an implicit conversion would be performed
 366 function SHL_STRONG(y) {
 367   if (IS_NUMBER(this) && IS_NUMBER(y)) {
 368     return %NumberShl(this, y);
 369   }
 370   throw %make_type_error(kStrongImplicitConversion);
 371 }
 372
 373
 374 // ECMA-262, section 11.7.2, page 51.
 375 function SAR(y) {
 376   var x;
 377   if (IS_NUMBER(this)) {
 378     x = this;
 379     if (!IS_NUMBER(y)) y = %non_number_to_number(y);
 380   } else {
 381     x = %non_number_to_number(this);
 382     // Make sure to convert the right operand to a number before
 383     // bailing out in the fast case, but after converting the
 384     // left operand. This ensures that valueOf methods on the right
 385     // operand are always executed.
 386     if (!IS_NUMBER(y)) y = %non_number_to_number(y);
 387     // Optimize for the case where we end up shifting a value
 388     // that doesn't convert to a number. This is common in
 389     // certain benchmarks.
 390     if (NUMBER_IS_NAN(x)) return 0;
 391   }
 392   return %NumberSar(x, y);
 393 }
 394
 395
 396 // Strong mode SAR throws if an implicit conversion would be performed
 397 function SAR_STRONG(y) {
 398   if (IS_NUMBER(this) && IS_NUMBER(y)) {
 399     return %NumberSar(this, y);
 400   }
 401   throw %make_type_error(kStrongImplicitConversion);
 402 }
 403
 404
 405 // ECMA-262, section 11.7.3, page 52.
 406 function SHR(y) {
 407   var x = IS_NUMBER(this) ? this : %non_number_to_number(this);
 408   if (!IS_NUMBER(y)) y = %non_number_to_number(y);
 409   return %NumberShr(x, y);
 410 }
 411
 412
 413 // Strong mode SHR throws if an implicit conversion would be performed
 414 function SHR_STRONG(y) {
 415   if (IS_NUMBER(this) && IS_NUMBER(y)) {
 416     return %NumberShr(this, y);
 417   }
 418   throw %make_type_error(kStrongImplicitConversion);
 419 }
 420
 421
 422 /* -----------------------------
 423    - - -   H e l p e r s   - - -
 424    -----------------------------
 425 */
 426
 427 // ECMA-262, section 11.8.7, page 54.
 428 function IN(x) {
 429   if (!IS_SPEC_OBJECT(x)) {
 430     throw %make_type_error(kInvalidInOperatorUse, this, x);
 431   }
 432   if (%_IsNonNegativeSmi(this)) {
 433     if (IS_ARRAY(x) && %_HasFastPackedElements(x)) {
 434       return this < x.length;
 435     }
 436     return %HasElement(x, this);
 437   }
 438   return %HasProperty(x, %to_name(this));
 439 }
 440
 441
 442 function CALL_NON_FUNCTION() {
 443   var delegate = %GetFunctionDelegate(this);
 444   if (!IS_FUNCTION(delegate)) {
 445     var callsite = %RenderCallSite();
 446     if (callsite == "") callsite = typeof this;
 447     throw %make_type_error(kCalledNonCallable, callsite);
 448   }
 449   return %Apply(delegate, this, arguments, 0, %_ArgumentsLength());
 450 }
 451
 452
 453 function CALL_NON_FUNCTION_AS_CONSTRUCTOR() {
 454   var delegate = %GetConstructorDelegate(this);
 455   if (!IS_FUNCTION(delegate)) {
 456     var callsite = %RenderCallSite();
 457     if (callsite == "") callsite = typeof this;
 458     throw %make_type_error(kCalledNonCallable, callsite);
 459   }
 460   return %Apply(delegate, this, arguments, 0, %_ArgumentsLength());
 461 }
 462
 463
 464 function CALL_FUNCTION_PROXY() {
 465   var arity = %_ArgumentsLength() - 1;
 466   var proxy = %_Arguments(arity);  // The proxy comes in as an additional arg.
 467   var trap = %GetCallTrap(proxy);
 468   return %Apply(trap, this, arguments, 0, arity);
 469 }
 470
 471
 472 function CALL_FUNCTION_PROXY_AS_CONSTRUCTOR () {
 473   var proxy = this;
 474   var trap = %GetConstructTrap(proxy);
 475   return %Apply(trap, this, arguments, 0, %_ArgumentsLength());
 476 }
 477
 478
 479 function APPLY_PREPARE(args) {
 480   var length;
 481   // First check whether length is a positive Smi and args is an
 482   // array. This is the fast case. If this fails, we do the slow case
 483   // that takes care of more eventualities.
 484   if (IS_ARRAY(args)) {
 485     length = args.length;
 486     if (%_IsSmi(length) && length >= 0 && length < kSafeArgumentsLength &&
 487         IS_SPEC_FUNCTION(this)) {
 488       return length;
 489     }
 490   }
 491
 492   length = (args == null) ? 0 : TO_UINT32(args.length);
 493
 494   // We can handle any number of apply arguments if the stack is
 495   // big enough, but sanity check the value to avoid overflow when
 496   // multiplying with pointer size.
 497   if (length > kSafeArgumentsLength) throw %make_range_error(kStackOverflow);
 498
 499   if (!IS_SPEC_FUNCTION(this)) {
 500     throw %make_type_error(kApplyNonFunction, %to_string_fun(this), typeof this);
 501   }
 502
 503   // Make sure the arguments list has the right type.
 504   if (args != null && !IS_SPEC_OBJECT(args)) {
 505     throw %make_type_error(kWrongArgs, "Function.prototype.apply");
 506   }
 507
 508   // Return the length which is the number of arguments to copy to the
 509   // stack. It is guaranteed to be a small integer at this point.
 510   return length;
 511 }
 512
 513
 514 function REFLECT_APPLY_PREPARE(args) {
 515   var length;
 516   // First check whether length is a positive Smi and args is an
 517   // array. This is the fast case. If this fails, we do the slow case
 518   // that takes care of more eventualities.
 519   if (IS_ARRAY(args)) {
 520     length = args.length;
 521     if (%_IsSmi(length) && length >= 0 && length < kSafeArgumentsLength &&
 522         IS_SPEC_FUNCTION(this)) {
 523       return length;
 524     }
 525   }
 526
 527   if (!IS_SPEC_FUNCTION(this)) {
 528     throw %make_type_error(kCalledNonCallable, %to_string_fun(this));
 529   }
 530
 531   if (!IS_SPEC_OBJECT(args)) {
 532     throw %make_type_error(kWrongArgs, "Reflect.apply");
 533   }
 534
 535   length = %to_length_fun(args.length);
 536
 537   // We can handle any number of apply arguments if the stack is
 538   // big enough, but sanity check the value to avoid overflow when
 539   // multiplying with pointer size.
 540   if (length > kSafeArgumentsLength) throw %make_range_error(kStackOverflow);
 541
 542   // Return the length which is the number of arguments to copy to the
 543   // stack. It is guaranteed to be a small integer at this point.
 544   return length;
 545 }
 546
 547
 548 function REFLECT_CONSTRUCT_PREPARE(
 549     args, newTarget) {
 550   var length;
 551   var ctorOk = IS_SPEC_FUNCTION(this) && %IsConstructor(this);
 552   var newTargetOk = IS_SPEC_FUNCTION(newTarget) && %IsConstructor(newTarget);
 553
 554   // First check whether length is a positive Smi and args is an
 555   // array. This is the fast case. If this fails, we do the slow case
 556   // that takes care of more eventualities.
 557   if (IS_ARRAY(args)) {
 558     length = args.length;
 559     if (%_IsSmi(length) && length >= 0 && length < kSafeArgumentsLength &&
 560         ctorOk && newTargetOk) {
 561       return length;
 562     }
 563   }
 564
 565   if (!ctorOk) {
 566     if (!IS_SPEC_FUNCTION(this)) {
 567       throw %make_type_error(kCalledNonCallable, %to_string_fun(this));
 568     } else {
 569       throw %make_type_error(kNotConstructor, %to_string_fun(this));
 570     }
 571   }
 572
 573   if (!newTargetOk) {
 574     if (!IS_SPEC_FUNCTION(newTarget)) {
 575       throw %make_type_error(kCalledNonCallable, %to_string_fun(newTarget));
 576     } else {
 577       throw %make_type_error(kNotConstructor, %to_string_fun(newTarget));
 578     }
 579   }
 580
 581   if (!IS_SPEC_OBJECT(args)) {
 582     throw %make_type_error(kWrongArgs, "Reflect.construct");
 583   }
 584
 585   length = %to_length_fun(args.length);
 586
 587   // We can handle any number of apply arguments if the stack is
 588   // big enough, but sanity check the value to avoid overflow when
 589   // multiplying with pointer size.
 590   if (length > kSafeArgumentsLength) throw %make_range_error(kStackOverflow);
 591
 592   // Return the length which is the number of arguments to copy to the
 593   // stack. It is guaranteed to be a small integer at this point.
 594   return length;
 595 }
 596
 597
 598 function CONCAT_ITERABLE_TO_ARRAY(iterable) {
 599   return %concat_iterable_to_array(this, iterable);
 600 };
 601
 602
 603 function STACK_OVERFLOW(length) {
 604   throw %make_range_error(kStackOverflow);
 605 }
 606
 607
 608 // Convert the receiver to a number - forward to ToNumber.
 609 function TO_NUMBER() {
 610   return %to_number_fun(this);
 611 }
 612
 613
 614 // Convert the receiver to a string - forward to ToString.
 615 function TO_STRING() {
 616   return %to_string_fun(this);
 617 }
 618
 619
 620 // Convert the receiver to a string or symbol - forward to ToName.
 621 function TO_NAME() {
 622   return %to_name(this);
 623 }
 624
 625
 626 /* -------------------------------------
 627    - - -   C o n v e r s i o n s   - - -
 628    -------------------------------------
 629 */
 630
 631 // ECMA-262, section 9.1, page 30. Use null/undefined for no hint,
 632 // (1) for number hint, and (2) for string hint.
 633 function ToPrimitive(x, hint) {
 634   if (!IS_SPEC_OBJECT(x)) return x;
 635   if (hint == NO_HINT) hint = (IS_DATE(x)) ? STRING_HINT : NUMBER_HINT;
 636   return (hint == NUMBER_HINT) ? DefaultNumber(x) : DefaultString(x);
 637 }
 638
 639
 640 // ECMA-262, section 9.2, page 30
 641 function ToBoolean(x) {
 642   if (IS_BOOLEAN(x)) return x;
 643   if (IS_STRING(x)) return x.length != 0;
 644   if (x == null) return false;
 645   if (IS_NUMBER(x)) return !((x == 0) || NUMBER_IS_NAN(x));
 646   return true;
 647 }
 648
 649
 650 // ECMA-262, section 9.3, page 31.
 651 function ToNumber(x) {
 652   if (IS_NUMBER(x)) return x;
 653   if (IS_STRING(x)) {
 654     return %_HasCachedArrayIndex(x) ? %_GetCachedArrayIndex(x)
 655                                     : %StringToNumber(x);
 656   }
 657   if (IS_BOOLEAN(x)) return x ? 1 : 0;
 658   if (IS_UNDEFINED(x)) return NAN;
 659   // Types that can't be converted to number are caught in DefaultNumber.
 660   return (IS_NULL(x)) ? 0 : ToNumber(DefaultNumber(x));
 661 }
 662
 663 function NonNumberToNumber(x) {
 664   if (IS_STRING(x)) {
 665     return %_HasCachedArrayIndex(x) ? %_GetCachedArrayIndex(x)
 666                                     : %StringToNumber(x);
 667   }
 668   if (IS_BOOLEAN(x)) return x ? 1 : 0;
 669   if (IS_UNDEFINED(x)) return NAN;
 670   // Types that can't be converted to number are caught in DefaultNumber.
 671   return (IS_NULL(x)) ? 0 : ToNumber(DefaultNumber(x));
 672 }
 673
 674
 675 // ECMA-262, section 9.8, page 35.
 676 function ToString(x) {
 677   if (IS_STRING(x)) return x;
 678   if (IS_NUMBER(x)) return %_NumberToString(x);
 679   if (IS_BOOLEAN(x)) return x ? 'true' : 'false';
 680   if (IS_UNDEFINED(x)) return 'undefined';
 681   // Types that can't be converted to string are caught in DefaultString.
 682   return (IS_NULL(x)) ? 'null' : ToString(DefaultString(x));
 683 }
 684
 685 function NonStringToString(x) {
 686   if (IS_NUMBER(x)) return %_NumberToString(x);
 687   if (IS_BOOLEAN(x)) return x ? 'true' : 'false';
 688   if (IS_UNDEFINED(x)) return 'undefined';
 689   // Types that can't be converted to string are caught in DefaultString.
 690   return (IS_NULL(x)) ? 'null' : ToString(DefaultString(x));
 691 }
 692
 693
 694 // ES6 symbols
 695 function ToName(x) {
 696   return IS_SYMBOL(x) ? x : ToString(x);
 697 }
 698
 699
 700 // ECMA-262, section 9.4, page 34.
 701 function ToInteger(x) {
 702   if (%_IsSmi(x)) return x;
 703   return %NumberToInteger(ToNumber(x));
 704 }
 705
 706
 707 // ES6, draft 08-24-14, section 7.1.15
 708 function ToLength(arg) {
 709   arg = ToInteger(arg);
 710   if (arg < 0) return 0;
 711   return arg < GlobalNumber.MAX_SAFE_INTEGER ? arg
 712                                              : GlobalNumber.MAX_SAFE_INTEGER;
 713 }
 714
 715
 716 // ES5, section 9.12
 717 function SameValue(x, y) {
 718   if (typeof x != typeof y) return false;
 719   if (IS_NUMBER(x)) {
 720     if (NUMBER_IS_NAN(x) && NUMBER_IS_NAN(y)) return true;
 721     // x is +0 and y is -0 or vice versa.
 722     if (x === 0 && y === 0 && %_IsMinusZero(x) != %_IsMinusZero(y)) {
 723       return false;
 724     }
 725   }
 726   if (IS_SIMD_VALUE(x)) return %SimdSameValue(x, y);
 727   return x === y;
 728 }
 729
 730
 731 // ES6, section 7.2.4
 732 function SameValueZero(x, y) {
 733   if (typeof x != typeof y) return false;
 734   if (IS_NUMBER(x)) {
 735     if (NUMBER_IS_NAN(x) && NUMBER_IS_NAN(y)) return true;
 736   }
 737   if (IS_SIMD_VALUE(x)) return %SimdSameValueZero(x, y);
 738   return x === y;
 739 }
 740
 741
 742 function ConcatIterableToArray(target, iterable) {
 743    var index = target.length;
 744    for (var element of iterable) {
 745      %AddElement(target, index++, element);
 746    }
 747    return target;
 748 }
 749
 750
 751 /* ---------------------------------
 752    - - -   U t i l i t i e s   - - -
 753    ---------------------------------
 754 */
 755
 756 // Returns if the given x is a primitive value - not an object or a
 757 // function.
 758 function IsPrimitive(x) {
 759   // Even though the type of null is "object", null is still
 760   // considered a primitive value. IS_SPEC_OBJECT handles this correctly
 761   // (i.e., it will return false if x is null).
 762   return !IS_SPEC_OBJECT(x);
 763 }
 764
 765
 766 // ES6, draft 10-14-14, section 22.1.3.1.1
 767 function IsConcatSpreadable(O) {
 768   if (!IS_SPEC_OBJECT(O)) return false;
 769   var spreadable = O[symbolIsConcatSpreadable];
 770   if (IS_UNDEFINED(spreadable)) return IS_ARRAY(O);
 771   return ToBoolean(spreadable);
 772 }
 773
 774
 775 // ECMA-262, section 8.6.2.6, page 28.
 776 function DefaultNumber(x) {
 777   var valueOf = x.valueOf;
 778   if (IS_SPEC_FUNCTION(valueOf)) {
 779     var v = %_CallFunction(x, valueOf);
 780     if (IS_SYMBOL(v)) throw MakeTypeError(kSymbolToNumber);
 781     if (IS_SIMD_VALUE(x)) throw MakeTypeError(kSimdToNumber);
 782     if (IsPrimitive(v)) return v;
 783   }
 784   var toString = x.toString;
 785   if (IS_SPEC_FUNCTION(toString)) {
 786     var s = %_CallFunction(x, toString);
 787     if (IsPrimitive(s)) return s;
 788   }
 789   throw MakeTypeError(kCannotConvertToPrimitive);
 790 }
 791
 792 // ECMA-262, section 8.6.2.6, page 28.
 793 function DefaultString(x) {
 794   if (!IS_SYMBOL_WRAPPER(x)) {
 795     if (IS_SYMBOL(x)) throw MakeTypeError(kSymbolToString);
 796     var toString = x.toString;
 797     if (IS_SPEC_FUNCTION(toString)) {
 798       var s = %_CallFunction(x, toString);
 799       if (IsPrimitive(s)) return s;
 800     }
 801
 802     var valueOf = x.valueOf;
 803     if (IS_SPEC_FUNCTION(valueOf)) {
 804       var v = %_CallFunction(x, valueOf);
 805       if (IsPrimitive(v)) return v;
 806     }
 807   }
 808   throw MakeTypeError(kCannotConvertToPrimitive);
 809 }
 810
 811 function ToPositiveInteger(x, rangeErrorIndex) {
 812   var i = TO_INTEGER_MAP_MINUS_ZERO(x);
 813   if (i < 0) throw MakeRangeError(rangeErrorIndex);
 814   return i;
 815 }
 816
 817 //----------------------------------------------------------------------------
 818
 819 // NOTE: Setting the prototype for Array must take place as early as
 820 // possible due to code generation for array literals.  When
 821 // generating code for a array literal a boilerplate array is created
 822 // that is cloned when running the code.  It is essential that the
 823 // boilerplate gets the right prototype.
 824 %FunctionSetPrototype(GlobalArray, new GlobalArray(0));
 825
 826 // ----------------------------------------------------------------------------
 827 // Exports
 828
 829 $defaultNumber = DefaultNumber;
 830 $defaultString = DefaultString;
 831 $NaN = %GetRootNaN();
 832 $nonNumberToNumber = NonNumberToNumber;
 833 $nonStringToString = NonStringToString;
 834 $sameValue = SameValue;
 835 $sameValueZero = SameValueZero;
 836 $toInteger = ToInteger;
 837 $toLength = ToLength;
 838 $toName = ToName;
 839 $toNumber = ToNumber;
 840 $toPositiveInteger = ToPositiveInteger;
 841 $toPrimitive = ToPrimitive;
 842 $toString = ToString;
 843
 844 %InstallToContext([
 845   "add_builtin", ADD,
 846   "add_strong_builtin", ADD_STRONG,
 847   "apply_prepare_builtin", APPLY_PREPARE,
 848   "bit_and_builtin", BIT_AND,
 849   "bit_and_strong_builtin", BIT_AND_STRONG,
 850   "bit_or_builtin", BIT_OR,
 851   "bit_or_strong_builtin", BIT_OR_STRONG,
 852   "bit_xor_builtin", BIT_XOR,
 853   "bit_xor_strong_builtin", BIT_XOR_STRONG,
 854   "call_function_proxy_as_constructor_builtin", CALL_FUNCTION_PROXY_AS_CONSTRUCTOR,
 855   "call_function_proxy_builtin", CALL_FUNCTION_PROXY,
 856   "call_non_function_as_constructor_builtin", CALL_NON_FUNCTION_AS_CONSTRUCTOR,
 857   "call_non_function_builtin", CALL_NON_FUNCTION,
 858   "compare_builtin", COMPARE,
 859   "compare_strong_builtin", COMPARE_STRONG,
 860   "concat_iterable_to_array_builtin", CONCAT_ITERABLE_TO_ARRAY,
 861   "div_builtin", DIV,
 862   "div_strong_builtin", DIV_STRONG,
 863   "equals_builtin", EQUALS,
 864   "in_builtin", IN,
 865   "mod_builtin", MOD,
 866   "mod_strong_builtin", MOD_STRONG,
 867   "mul_builtin", MUL,
 868   "mul_strong_builtin", MUL_STRONG,
 869   "reflect_apply_prepare_builtin", REFLECT_APPLY_PREPARE,
 870   "reflect_construct_prepare_builtin", REFLECT_CONSTRUCT_PREPARE,
 871   "sar_builtin", SAR,
 872   "sar_strong_builtin", SAR_STRONG,
 873   "shl_builtin", SHL,
 874   "shl_strong_builtin", SHL_STRONG,
 875   "shr_builtin", SHR,
 876   "shr_strong_builtin", SHR_STRONG,
 877   "stack_overflow_builtin", STACK_OVERFLOW,
 878   "string_add_left_builtin", STRING_ADD_LEFT,
 879   "string_add_right_builtin", STRING_ADD_RIGHT,
 880   "sub_builtin", SUB,
 881   "sub_strong_builtin", SUB_STRONG,
 882   "to_name_builtin", TO_NAME,
 883   "to_number_builtin", TO_NUMBER,
 884   "to_string_builtin", TO_STRING,
 885 ]);
 886
 887 %InstallToContext([
 888   "concat_iterable_to_array", ConcatIterableToArray,
 889   "non_number_to_number", NonNumberToNumber,
 890   "non_string_to_string", NonStringToString,
 891   "to_integer_fun", ToInteger,
 892   "to_length_fun", ToLength,
 893   "to_name", ToName,
 894   "to_number_fun", ToNumber,
 895   "to_primitive", ToPrimitive,
 896   "to_string_fun", ToString,
 897 ]);
 898
 899 utils.Export(function(to) {
 900   to.ToBoolean = ToBoolean;
 901   to.ToLength = ToLength;
 902   to.ToName = ToName;
 903   to.ToNumber = ToNumber;
 904   to.ToPrimitive = ToPrimitive;
 905   to.ToString = ToString;
 906 });
 907
 908 })