src/v8/src/compiler/typer.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/compiler/graph-inl.h"
   6 #include "src/compiler/js-operator.h"
   7 #include "src/compiler/node.h"
   8 #include "src/compiler/node-properties-inl.h"
   9 #include "src/compiler/node-properties.h"
  10 #include "src/compiler/simplified-operator.h"
  11 #include "src/compiler/typer.h"
  12
  13 namespace v8 {
  14 namespace internal {
  15 namespace compiler {
  16
  17 Typer::Typer(Zone* zone) : zone_(zone) {
  18   Type* number = Type::Number(zone);
  19   Type* signed32 = Type::Signed32(zone);
  20   Type* unsigned32 = Type::Unsigned32(zone);
  21   Type* integral32 = Type::Integral32(zone);
  22   Type* object = Type::Object(zone);
  23   Type* undefined = Type::Undefined(zone);
  24   number_fun0_ = Type::Function(number, zone);
  25   number_fun1_ = Type::Function(number, number, zone);
  26   number_fun2_ = Type::Function(number, number, number, zone);
  27   imul_fun_ = Type::Function(signed32, integral32, integral32, zone);
  28
  29 #define NATIVE_TYPE(sem, rep) \
  30   Type::Intersect(Type::sem(zone), Type::rep(zone), zone)
  31   // TODO(rossberg): Use range types for more precision, once we have them.
  32   Type* int8 = NATIVE_TYPE(SignedSmall, UntaggedInt8);
  33   Type* int16 = NATIVE_TYPE(SignedSmall, UntaggedInt16);
  34   Type* int32 = NATIVE_TYPE(Signed32, UntaggedInt32);
  35   Type* uint8 = NATIVE_TYPE(UnsignedSmall, UntaggedInt8);
  36   Type* uint16 = NATIVE_TYPE(UnsignedSmall, UntaggedInt16);
  37   Type* uint32 = NATIVE_TYPE(Unsigned32, UntaggedInt32);
  38   Type* float32 = NATIVE_TYPE(Number, UntaggedFloat32);
  39   Type* float64 = NATIVE_TYPE(Number, UntaggedFloat64);
  40 #undef NATIVE_TYPE
  41   Type* buffer = Type::Buffer(zone);
  42   Type* int8_array = Type::Array(int8, zone);
  43   Type* int16_array = Type::Array(int16, zone);
  44   Type* int32_array = Type::Array(int32, zone);
  45   Type* uint8_array = Type::Array(uint8, zone);
  46   Type* uint16_array = Type::Array(uint16, zone);
  47   Type* uint32_array = Type::Array(uint32, zone);
  48   Type* float32_array = Type::Array(float32, zone);
  49   Type* float64_array = Type::Array(float64, zone);
  50   Type* arg1 = Type::Union(unsigned32, object, zone);
  51   Type* arg2 = Type::Union(unsigned32, undefined, zone);
  52   Type* arg3 = arg2;
  53   array_buffer_fun_ = Type::Function(buffer, unsigned32, zone);
  54   int8_array_fun_ = Type::Function(int8_array, arg1, arg2, arg3, zone);
  55   int16_array_fun_ = Type::Function(int16_array, arg1, arg2, arg3, zone);
  56   int32_array_fun_ = Type::Function(int32_array, arg1, arg2, arg3, zone);
  57   uint8_array_fun_ = Type::Function(uint8_array, arg1, arg2, arg3, zone);
  58   uint16_array_fun_ = Type::Function(uint16_array, arg1, arg2, arg3, zone);
  59   uint32_array_fun_ = Type::Function(uint32_array, arg1, arg2, arg3, zone);
  60   float32_array_fun_ = Type::Function(float32_array, arg1, arg2, arg3, zone);
  61   float64_array_fun_ = Type::Function(float64_array, arg1, arg2, arg3, zone);
  62 }
  63
  64
  65 class Typer::Visitor : public NullNodeVisitor {
  66  public:
  67   Visitor(Typer* typer, MaybeHandle<Context> context)
  68       : typer_(typer), context_(context) {}
  69
  70   Bounds TypeNode(Node* node) {
  71     switch (node->opcode()) {
  72 #define DECLARE_CASE(x) case IrOpcode::k##x: return Type##x(node);
  73       DECLARE_CASE(Start)
  74       VALUE_OP_LIST(DECLARE_CASE)
  75 #undef DECLARE_CASE
  76
  77 #define DECLARE_CASE(x) case IrOpcode::k##x:
  78       DECLARE_CASE(End)
  79       INNER_CONTROL_OP_LIST(DECLARE_CASE)
  80 #undef DECLARE_CASE
  81       break;
  82     }
  83     UNREACHABLE();
  84     return Bounds();
  85   }
  86
  87   Type* TypeConstant(Handle<Object> value);
  88
  89  protected:
  90 #define DECLARE_METHOD(x) inline Bounds Type##x(Node* node);
  91   DECLARE_METHOD(Start)
  92   VALUE_OP_LIST(DECLARE_METHOD)
  93 #undef DECLARE_METHOD
  94
  95   Bounds OperandType(Node* node, int i) {
  96     return NodeProperties::GetBounds(NodeProperties::GetValueInput(node, i));
  97   }
  98
  99   Type* ContextType(Node* node) {
 100     Bounds result =
 101         NodeProperties::GetBounds(NodeProperties::GetContextInput(node));
 102     DCHECK(result.upper->Maybe(Type::Internal()));
 103     // TODO(rossberg): More precisely, instead of the above assertion, we should
 104     // back-propagate the constraint that it has to be a subtype of Internal.
 105     return result.upper;
 106   }
 107
 108   Zone* zone() { return typer_->zone(); }
 109   Isolate* isolate() { return typer_->isolate(); }
 110   MaybeHandle<Context> context() { return context_; }
 111
 112  private:
 113   Typer* typer_;
 114   MaybeHandle<Context> context_;
 115 };
 116
 117
 118 class Typer::RunVisitor : public Typer::Visitor {
 119  public:
 120   RunVisitor(Typer* typer, MaybeHandle<Context> context)
 121       : Visitor(typer, context),
 122         redo(NodeSet::key_compare(), NodeSet::allocator_type(typer->zone())) {}
 123
 124   GenericGraphVisit::Control Post(Node* node) {
 125     if (OperatorProperties::HasValueOutput(node->op())) {
 126       Bounds bounds = TypeNode(node);
 127       NodeProperties::SetBounds(node, bounds);
 128       // Remember incompletely typed nodes for least fixpoint iteration.
 129       int arity = OperatorProperties::GetValueInputCount(node->op());
 130       for (int i = 0; i < arity; ++i) {
 131         // TODO(rossberg): change once IsTyped is available.
 132         // if (!NodeProperties::IsTyped(NodeProperties::GetValueInput(node, i)))
 133         if (OperandType(node, i).upper->Is(Type::None())) {
 134           redo.insert(node);
 135           break;
 136         }
 137       }
 138     }
 139     return GenericGraphVisit::CONTINUE;
 140   }
 141
 142   NodeSet redo;
 143 };
 144
 145
 146 class Typer::NarrowVisitor : public Typer::Visitor {
 147  public:
 148   NarrowVisitor(Typer* typer, MaybeHandle<Context> context)
 149       : Visitor(typer, context) {}
 150
 151   GenericGraphVisit::Control Pre(Node* node) {
 152     if (OperatorProperties::HasValueOutput(node->op())) {
 153       Bounds previous = NodeProperties::GetBounds(node);
 154       Bounds bounds = TypeNode(node);
 155       NodeProperties::SetBounds(node, Bounds::Both(bounds, previous, zone()));
 156       DCHECK(bounds.Narrows(previous));
 157       // Stop when nothing changed (but allow re-entry in case it does later).
 158       return previous.Narrows(bounds)
 159           ? GenericGraphVisit::DEFER : GenericGraphVisit::REENTER;
 160     } else {
 161       return GenericGraphVisit::SKIP;
 162     }
 163   }
 164
 165   GenericGraphVisit::Control Post(Node* node) {
 166     return GenericGraphVisit::REENTER;
 167   }
 168 };
 169
 170
 171 class Typer::WidenVisitor : public Typer::Visitor {
 172  public:
 173   WidenVisitor(Typer* typer, MaybeHandle<Context> context)
 174       : Visitor(typer, context) {}
 175
 176   GenericGraphVisit::Control Pre(Node* node) {
 177     if (OperatorProperties::HasValueOutput(node->op())) {
 178       Bounds previous = NodeProperties::GetBounds(node);
 179       Bounds bounds = TypeNode(node);
 180       DCHECK(previous.lower->Is(bounds.lower));
 181       DCHECK(previous.upper->Is(bounds.upper));
 182       NodeProperties::SetBounds(node, bounds);  // TODO(rossberg): Either?
 183       // Stop when nothing changed (but allow re-entry in case it does later).
 184       return bounds.Narrows(previous)
 185           ? GenericGraphVisit::DEFER : GenericGraphVisit::REENTER;
 186     } else {
 187       return GenericGraphVisit::SKIP;
 188     }
 189   }
 190
 191   GenericGraphVisit::Control Post(Node* node) {
 192     return GenericGraphVisit::REENTER;
 193   }
 194 };
 195
 196
 197 void Typer::Run(Graph* graph, MaybeHandle<Context> context) {
 198   RunVisitor typing(this, context);
 199   graph->VisitNodeInputsFromEnd(&typing);
 200   // Find least fixpoint.
 201   for (NodeSetIter i = typing.redo.begin(); i != typing.redo.end(); ++i) {
 202     Widen(graph, *i, context);
 203   }
 204 }
 205
 206
 207 void Typer::Narrow(Graph* graph, Node* start, MaybeHandle<Context> context) {
 208   NarrowVisitor typing(this, context);
 209   graph->VisitNodeUsesFrom(start, &typing);
 210 }
 211
 212
 213 void Typer::Widen(Graph* graph, Node* start, MaybeHandle<Context> context) {
 214   WidenVisitor typing(this, context);
 215   graph->VisitNodeUsesFrom(start, &typing);
 216 }
 217
 218
 219 void Typer::Init(Node* node) {
 220   if (OperatorProperties::HasValueOutput(node->op())) {
 221     Visitor typing(this, MaybeHandle<Context>());
 222     Bounds bounds = typing.TypeNode(node);
 223     NodeProperties::SetBounds(node, bounds);
 224   }
 225 }
 226
 227
 228 // -----------------------------------------------------------------------------
 229
 230
 231 // Control operators.
 232
 233 Bounds Typer::Visitor::TypeStart(Node* node) {
 234   return Bounds(Type::Internal(zone()));
 235 }
 236
 237
 238 // Common operators.
 239
 240 Bounds Typer::Visitor::TypeParameter(Node* node) {
 241   return Bounds::Unbounded(zone());
 242 }
 243
 244
 245 Bounds Typer::Visitor::TypeInt32Constant(Node* node) {
 246   // TODO(titzer): only call Type::Of() if the type is not already known.
 247   return Bounds(Type::Of(OpParameter<int32_t>(node), zone()));
 248 }
 249
 250
 251 Bounds Typer::Visitor::TypeInt64Constant(Node* node) {
 252   // TODO(titzer): only call Type::Of() if the type is not already known.
 253   return Bounds(
 254       Type::Of(static_cast<double>(OpParameter<int64_t>(node)), zone()));
 255 }
 256
 257
 258 Bounds Typer::Visitor::TypeFloat32Constant(Node* node) {
 259   // TODO(titzer): only call Type::Of() if the type is not already known.
 260   return Bounds(Type::Of(OpParameter<float>(node), zone()));
 261 }
 262
 263
 264 Bounds Typer::Visitor::TypeFloat64Constant(Node* node) {
 265   // TODO(titzer): only call Type::Of() if the type is not already known.
 266   return Bounds(Type::Of(OpParameter<double>(node), zone()));
 267 }
 268
 269
 270 Bounds Typer::Visitor::TypeNumberConstant(Node* node) {
 271   // TODO(titzer): only call Type::Of() if the type is not already known.
 272   return Bounds(Type::Of(OpParameter<double>(node), zone()));
 273 }
 274
 275
 276 Bounds Typer::Visitor::TypeHeapConstant(Node* node) {
 277   return Bounds(TypeConstant(OpParameter<Unique<Object> >(node).handle()));
 278 }
 279
 280
 281 Bounds Typer::Visitor::TypeExternalConstant(Node* node) {
 282   return Bounds(Type::Internal(zone()));
 283 }
 284
 285
 286 Bounds Typer::Visitor::TypePhi(Node* node) {
 287   int arity = OperatorProperties::GetValueInputCount(node->op());
 288   Bounds bounds = OperandType(node, 0);
 289   for (int i = 1; i < arity; ++i) {
 290     bounds = Bounds::Either(bounds, OperandType(node, i), zone());
 291   }
 292   return bounds;
 293 }
 294
 295
 296 Bounds Typer::Visitor::TypeEffectPhi(Node* node) {
 297   UNREACHABLE();
 298   return Bounds();
 299 }
 300
 301
 302 Bounds Typer::Visitor::TypeControlEffect(Node* node) {
 303   UNREACHABLE();
 304   return Bounds();
 305 }
 306
 307
 308 Bounds Typer::Visitor::TypeValueEffect(Node* node) {
 309   UNREACHABLE();
 310   return Bounds();
 311 }
 312
 313
 314 Bounds Typer::Visitor::TypeFinish(Node* node) {
 315   return OperandType(node, 0);
 316 }
 317
 318
 319 Bounds Typer::Visitor::TypeFrameState(Node* node) {
 320   // TODO(rossberg): Ideally FrameState wouldn't have a value output.
 321   return Bounds(Type::Internal(zone()));
 322 }
 323
 324
 325 Bounds Typer::Visitor::TypeStateValues(Node* node) {
 326   return Bounds(Type::Internal(zone()));
 327 }
 328
 329
 330 Bounds Typer::Visitor::TypeCall(Node* node) {
 331   return Bounds::Unbounded(zone());
 332 }
 333
 334
 335 Bounds Typer::Visitor::TypeProjection(Node* node) {
 336   // TODO(titzer): use the output type of the input to determine the bounds.
 337   return Bounds::Unbounded(zone());
 338 }
 339
 340
 341 // JS comparison operators.
 342
 343 #define DEFINE_METHOD(x)                       \
 344   Bounds Typer::Visitor::Type##x(Node* node) { \
 345     return Bounds(Type::Boolean(zone()));      \
 346   }
 347 JS_COMPARE_BINOP_LIST(DEFINE_METHOD)
 348 #undef DEFINE_METHOD
 349
 350
 351 // JS bitwise operators.
 352
 353 Bounds Typer::Visitor::TypeJSBitwiseOr(Node* node) {
 354   Bounds left = OperandType(node, 0);
 355   Bounds right = OperandType(node, 1);
 356   Type* upper = Type::Union(left.upper, right.upper, zone());
 357   if (!upper->Is(Type::Signed32())) upper = Type::Signed32(zone());
 358   Type* lower = Type::Intersect(Type::SignedSmall(zone()), upper, zone());
 359   return Bounds(lower, upper);
 360 }
 361
 362
 363 Bounds Typer::Visitor::TypeJSBitwiseAnd(Node* node) {
 364   Bounds left = OperandType(node, 0);
 365   Bounds right = OperandType(node, 1);
 366   Type* upper = Type::Union(left.upper, right.upper, zone());
 367   if (!upper->Is(Type::Signed32())) upper = Type::Signed32(zone());
 368   Type* lower = Type::Intersect(Type::SignedSmall(zone()), upper, zone());
 369   return Bounds(lower, upper);
 370 }
 371
 372
 373 Bounds Typer::Visitor::TypeJSBitwiseXor(Node* node) {
 374   return Bounds(Type::SignedSmall(zone()), Type::Signed32(zone()));
 375 }
 376
 377
 378 Bounds Typer::Visitor::TypeJSShiftLeft(Node* node) {
 379   return Bounds(Type::SignedSmall(zone()), Type::Signed32(zone()));
 380 }
 381
 382
 383 Bounds Typer::Visitor::TypeJSShiftRight(Node* node) {
 384   return Bounds(Type::SignedSmall(zone()), Type::Signed32(zone()));
 385 }
 386
 387
 388 Bounds Typer::Visitor::TypeJSShiftRightLogical(Node* node) {
 389   return Bounds(Type::UnsignedSmall(zone()), Type::Unsigned32(zone()));
 390 }
 391
 392
 393 // JS arithmetic operators.
 394
 395 Bounds Typer::Visitor::TypeJSAdd(Node* node) {
 396   Bounds left = OperandType(node, 0);
 397   Bounds right = OperandType(node, 1);
 398   Type* lower =
 399       left.lower->Is(Type::None()) || right.lower->Is(Type::None()) ?
 400           Type::None(zone()) :
 401       left.lower->Is(Type::Number()) && right.lower->Is(Type::Number()) ?
 402           Type::SignedSmall(zone()) :
 403       left.lower->Is(Type::String()) || right.lower->Is(Type::String()) ?
 404           Type::String(zone()) : Type::None(zone());
 405   Type* upper =
 406       left.upper->Is(Type::None()) && right.upper->Is(Type::None()) ?
 407           Type::None(zone()) :
 408       left.upper->Is(Type::Number()) && right.upper->Is(Type::Number()) ?
 409           Type::Number(zone()) :
 410       left.upper->Is(Type::String()) || right.upper->Is(Type::String()) ?
 411           Type::String(zone()) : Type::NumberOrString(zone());
 412   return Bounds(lower, upper);
 413 }
 414
 415
 416 Bounds Typer::Visitor::TypeJSSubtract(Node* node) {
 417   return Bounds(Type::SignedSmall(zone()), Type::Number(zone()));
 418 }
 419
 420
 421 Bounds Typer::Visitor::TypeJSMultiply(Node* node) {
 422   return Bounds(Type::SignedSmall(zone()), Type::Number(zone()));
 423 }
 424
 425
 426 Bounds Typer::Visitor::TypeJSDivide(Node* node) {
 427   return Bounds(Type::SignedSmall(zone()), Type::Number(zone()));
 428 }
 429
 430
 431 Bounds Typer::Visitor::TypeJSModulus(Node* node) {
 432   return Bounds(Type::SignedSmall(zone()), Type::Number(zone()));
 433 }
 434
 435
 436 // JS unary operators.
 437
 438 Bounds Typer::Visitor::TypeJSUnaryNot(Node* node) {
 439   return Bounds(Type::Boolean(zone()));
 440 }
 441
 442
 443 Bounds Typer::Visitor::TypeJSTypeOf(Node* node) {
 444   return Bounds(Type::InternalizedString(zone()));
 445 }
 446
 447
 448 // JS conversion operators.
 449
 450 Bounds Typer::Visitor::TypeJSToBoolean(Node* node) {
 451   return Bounds(Type::Boolean(zone()));
 452 }
 453
 454
 455 Bounds Typer::Visitor::TypeJSToNumber(Node* node) {
 456   return Bounds(Type::SignedSmall(zone()), Type::Number(zone()));
 457 }
 458
 459
 460 Bounds Typer::Visitor::TypeJSToString(Node* node) {
 461   return Bounds(Type::None(zone()), Type::String(zone()));
 462 }
 463
 464
 465 Bounds Typer::Visitor::TypeJSToName(Node* node) {
 466   return Bounds(Type::None(zone()), Type::Name(zone()));
 467 }
 468
 469
 470 Bounds Typer::Visitor::TypeJSToObject(Node* node) {
 471   return Bounds(Type::None(zone()), Type::Receiver(zone()));
 472 }
 473
 474
 475 // JS object operators.
 476
 477 Bounds Typer::Visitor::TypeJSCreate(Node* node) {
 478   return Bounds(Type::None(zone()), Type::Object(zone()));
 479 }
 480
 481
 482 Bounds Typer::Visitor::TypeJSLoadProperty(Node* node) {
 483   Bounds object = OperandType(node, 0);
 484   Bounds name = OperandType(node, 1);
 485   Bounds result = Bounds::Unbounded(zone());
 486   // TODO(rossberg): Use range types and sized array types to filter undefined.
 487   if (object.lower->IsArray() && name.lower->Is(Type::Integral32())) {
 488     result.lower = Type::Union(
 489         object.lower->AsArray()->Element(), Type::Undefined(zone()), zone());
 490   }
 491   if (object.upper->IsArray() && name.upper->Is(Type::Integral32())) {
 492     result.upper = Type::Union(
 493         object.upper->AsArray()->Element(),  Type::Undefined(zone()), zone());
 494   }
 495   return result;
 496 }
 497
 498
 499 Bounds Typer::Visitor::TypeJSLoadNamed(Node* node) {
 500   return Bounds::Unbounded(zone());
 501 }
 502
 503
 504 Bounds Typer::Visitor::TypeJSStoreProperty(Node* node) {
 505   UNREACHABLE();
 506   return Bounds();
 507 }
 508
 509
 510 Bounds Typer::Visitor::TypeJSStoreNamed(Node* node) {
 511   UNREACHABLE();
 512   return Bounds();
 513 }
 514
 515
 516 Bounds Typer::Visitor::TypeJSDeleteProperty(Node* node) {
 517   return Bounds(Type::Boolean(zone()));
 518 }
 519
 520
 521 Bounds Typer::Visitor::TypeJSHasProperty(Node* node) {
 522   return Bounds(Type::Boolean(zone()));
 523 }
 524
 525
 526 Bounds Typer::Visitor::TypeJSInstanceOf(Node* node) {
 527   return Bounds(Type::Boolean(zone()));
 528 }
 529
 530
 531 // JS context operators.
 532
 533 Bounds Typer::Visitor::TypeJSLoadContext(Node* node) {
 534   Bounds outer = OperandType(node, 0);
 535   DCHECK(outer.upper->Maybe(Type::Internal()));
 536   // TODO(rossberg): More precisely, instead of the above assertion, we should
 537   // back-propagate the constraint that it has to be a subtype of Internal.
 538
 539   ContextAccess access = OpParameter<ContextAccess>(node);
 540   Type* context_type = outer.upper;
 541   MaybeHandle<Context> context;
 542   if (context_type->IsConstant()) {
 543     context = Handle<Context>::cast(context_type->AsConstant()->Value());
 544   }
 545   // Walk context chain (as far as known), mirroring dynamic lookup.
 546   // Since contexts are mutable, the information is only useful as a lower
 547   // bound.
 548   // TODO(rossberg): Could use scope info to fix upper bounds for constant
 549   // bindings if we know that this code is never shared.
 550   for (int i = access.depth(); i > 0; --i) {
 551     if (context_type->IsContext()) {
 552       context_type = context_type->AsContext()->Outer();
 553       if (context_type->IsConstant()) {
 554         context = Handle<Context>::cast(context_type->AsConstant()->Value());
 555       }
 556     } else if (!context.is_null()) {
 557       context = handle(context.ToHandleChecked()->previous(), isolate());
 558     }
 559   }
 560   if (context.is_null()) {
 561     return Bounds::Unbounded(zone());
 562   } else {
 563     Handle<Object> value =
 564         handle(context.ToHandleChecked()->get(access.index()), isolate());
 565     Type* lower = TypeConstant(value);
 566     return Bounds(lower, Type::Any(zone()));
 567   }
 568 }
 569
 570
 571 Bounds Typer::Visitor::TypeJSStoreContext(Node* node) {
 572   UNREACHABLE();
 573   return Bounds();
 574 }
 575
 576
 577 Bounds Typer::Visitor::TypeJSCreateFunctionContext(Node* node) {
 578   Type* outer = ContextType(node);
 579   return Bounds(Type::Context(outer, zone()));
 580 }
 581
 582
 583 Bounds Typer::Visitor::TypeJSCreateCatchContext(Node* node) {
 584   Type* outer = ContextType(node);
 585   return Bounds(Type::Context(outer, zone()));
 586 }
 587
 588
 589 Bounds Typer::Visitor::TypeJSCreateWithContext(Node* node) {
 590   Type* outer = ContextType(node);
 591   return Bounds(Type::Context(outer, zone()));
 592 }
 593
 594
 595 Bounds Typer::Visitor::TypeJSCreateBlockContext(Node* node) {
 596   Type* outer = ContextType(node);
 597   return Bounds(Type::Context(outer, zone()));
 598 }
 599
 600
 601 Bounds Typer::Visitor::TypeJSCreateModuleContext(Node* node) {
 602   // TODO(rossberg): this is probably incorrect
 603   Type* outer = ContextType(node);
 604   return Bounds(Type::Context(outer, zone()));
 605 }
 606
 607
 608 Bounds Typer::Visitor::TypeJSCreateGlobalContext(Node* node) {
 609   Type* outer = ContextType(node);
 610   return Bounds(Type::Context(outer, zone()));
 611 }
 612
 613
 614 // JS other operators.
 615
 616 Bounds Typer::Visitor::TypeJSYield(Node* node) {
 617   return Bounds::Unbounded(zone());
 618 }
 619
 620
 621 Bounds Typer::Visitor::TypeJSCallConstruct(Node* node) {
 622   return Bounds(Type::None(zone()), Type::Receiver(zone()));
 623 }
 624
 625
 626 Bounds Typer::Visitor::TypeJSCallFunction(Node* node) {
 627   Bounds fun = OperandType(node, 0);
 628   Type* lower = fun.lower->IsFunction()
 629       ? fun.lower->AsFunction()->Result() : Type::None(zone());
 630   Type* upper = fun.upper->IsFunction()
 631       ? fun.upper->AsFunction()->Result() : Type::Any(zone());
 632   return Bounds(lower, upper);
 633 }
 634
 635
 636 Bounds Typer::Visitor::TypeJSCallRuntime(Node* node) {
 637   return Bounds::Unbounded(zone());
 638 }
 639
 640
 641 Bounds Typer::Visitor::TypeJSDebugger(Node* node) {
 642   return Bounds::Unbounded(zone());
 643 }
 644
 645
 646 // Simplified operators.
 647
 648 Bounds Typer::Visitor::TypeBooleanNot(Node* node) {
 649   return Bounds(Type::Boolean(zone()));
 650 }
 651
 652
 653 Bounds Typer::Visitor::TypeBooleanToNumber(Node* node) {
 654   return Bounds(Type::Number(zone()));
 655 }
 656
 657
 658 Bounds Typer::Visitor::TypeNumberEqual(Node* node) {
 659   return Bounds(Type::Boolean(zone()));
 660 }
 661
 662
 663 Bounds Typer::Visitor::TypeNumberLessThan(Node* node) {
 664   return Bounds(Type::Boolean(zone()));
 665 }
 666
 667
 668 Bounds Typer::Visitor::TypeNumberLessThanOrEqual(Node* node) {
 669   return Bounds(Type::Boolean(zone()));
 670 }
 671
 672
 673 Bounds Typer::Visitor::TypeNumberAdd(Node* node) {
 674   return Bounds(Type::Number(zone()));
 675 }
 676
 677
 678 Bounds Typer::Visitor::TypeNumberSubtract(Node* node) {
 679   return Bounds(Type::Number(zone()));
 680 }
 681
 682
 683 Bounds Typer::Visitor::TypeNumberMultiply(Node* node) {
 684   return Bounds(Type::Number(zone()));
 685 }
 686
 687
 688 Bounds Typer::Visitor::TypeNumberDivide(Node* node) {
 689   return Bounds(Type::Number(zone()));
 690 }
 691
 692
 693 Bounds Typer::Visitor::TypeNumberModulus(Node* node) {
 694   return Bounds(Type::Number(zone()));
 695 }
 696
 697
 698 Bounds Typer::Visitor::TypeNumberToInt32(Node* node) {
 699   Bounds arg = OperandType(node, 0);
 700   Type* s32 = Type::Signed32(zone());
 701   Type* lower = arg.lower->Is(s32) ? arg.lower : s32;
 702   Type* upper = arg.upper->Is(s32) ? arg.upper : s32;
 703   return Bounds(lower, upper);
 704 }
 705
 706
 707 Bounds Typer::Visitor::TypeNumberToUint32(Node* node) {
 708   Bounds arg = OperandType(node, 0);
 709   Type* u32 = Type::Unsigned32(zone());
 710   Type* lower = arg.lower->Is(u32) ? arg.lower : u32;
 711   Type* upper = arg.upper->Is(u32) ? arg.upper : u32;
 712   return Bounds(lower, upper);
 713 }
 714
 715
 716 Bounds Typer::Visitor::TypeReferenceEqual(Node* node) {
 717   return Bounds(Type::Boolean(zone()));
 718 }
 719
 720
 721 Bounds Typer::Visitor::TypeStringEqual(Node* node) {
 722   return Bounds(Type::Boolean(zone()));
 723 }
 724
 725
 726 Bounds Typer::Visitor::TypeStringLessThan(Node* node) {
 727   return Bounds(Type::Boolean(zone()));
 728 }
 729
 730
 731 Bounds Typer::Visitor::TypeStringLessThanOrEqual(Node* node) {
 732   return Bounds(Type::Boolean(zone()));
 733 }
 734
 735
 736 Bounds Typer::Visitor::TypeStringAdd(Node* node) {
 737   return Bounds(Type::String(zone()));
 738 }
 739
 740
 741 Bounds Typer::Visitor::TypeChangeTaggedToInt32(Node* node) {
 742   // TODO(titzer): type is type of input, representation is Word32.
 743   return Bounds(Type::Integral32());
 744 }
 745
 746
 747 Bounds Typer::Visitor::TypeChangeTaggedToUint32(Node* node) {
 748   return Bounds(Type::Integral32());  // TODO(titzer): add appropriate rep
 749 }
 750
 751
 752 Bounds Typer::Visitor::TypeChangeTaggedToFloat64(Node* node) {
 753   // TODO(titzer): type is type of input, representation is Float64.
 754   return Bounds(Type::Number());
 755 }
 756
 757
 758 Bounds Typer::Visitor::TypeChangeInt32ToTagged(Node* node) {
 759   // TODO(titzer): type is type of input, representation is Tagged.
 760   return Bounds(Type::Integral32());
 761 }
 762
 763
 764 Bounds Typer::Visitor::TypeChangeUint32ToTagged(Node* node) {
 765   // TODO(titzer): type is type of input, representation is Tagged.
 766   return Bounds(Type::Unsigned32());
 767 }
 768
 769
 770 Bounds Typer::Visitor::TypeChangeFloat64ToTagged(Node* node) {
 771   // TODO(titzer): type is type of input, representation is Tagged.
 772   return Bounds(Type::Number());
 773 }
 774
 775
 776 Bounds Typer::Visitor::TypeChangeBoolToBit(Node* node) {
 777   // TODO(titzer): type is type of input, representation is Bit.
 778   return Bounds(Type::Boolean());
 779 }
 780
 781
 782 Bounds Typer::Visitor::TypeChangeBitToBool(Node* node) {
 783   // TODO(titzer): type is type of input, representation is Tagged.
 784   return Bounds(Type::Boolean());
 785 }
 786
 787
 788 Bounds Typer::Visitor::TypeLoadField(Node* node) {
 789   return Bounds(FieldAccessOf(node->op()).type);
 790 }
 791
 792
 793 Bounds Typer::Visitor::TypeLoadElement(Node* node) {
 794   return Bounds(ElementAccessOf(node->op()).type);
 795 }
 796
 797
 798 Bounds Typer::Visitor::TypeStoreField(Node* node) {
 799   UNREACHABLE();
 800   return Bounds();
 801 }
 802
 803
 804 Bounds Typer::Visitor::TypeStoreElement(Node* node) {
 805   UNREACHABLE();
 806   return Bounds();
 807 }
 808
 809
 810 // Machine operators.
 811
 812 // TODO(rossberg): implement
 813 #define DEFINE_METHOD(x) \
 814     Bounds Typer::Visitor::Type##x(Node* node) { return Bounds(Type::None()); }
 815 MACHINE_OP_LIST(DEFINE_METHOD)
 816 #undef DEFINE_METHOD
 817
 818
 819 // Heap constants.
 820
 821 Type* Typer::Visitor::TypeConstant(Handle<Object> value) {
 822   if (value->IsJSFunction() && JSFunction::cast(*value)->IsBuiltin() &&
 823       !context().is_null()) {
 824     Handle<Context> native =
 825         handle(context().ToHandleChecked()->native_context(), isolate());
 826     if (*value == native->math_abs_fun()) {
 827       return typer_->number_fun1_;  // TODO(rossberg): can't express overloading
 828     } else if (*value == native->math_acos_fun()) {
 829       return typer_->number_fun1_;
 830     } else if (*value == native->math_asin_fun()) {
 831       return typer_->number_fun1_;
 832     } else if (*value == native->math_atan_fun()) {
 833       return typer_->number_fun1_;
 834     } else if (*value == native->math_atan2_fun()) {
 835       return typer_->number_fun2_;
 836     } else if (*value == native->math_ceil_fun()) {
 837       return typer_->number_fun1_;
 838     } else if (*value == native->math_cos_fun()) {
 839       return typer_->number_fun1_;
 840     } else if (*value == native->math_exp_fun()) {
 841       return typer_->number_fun1_;
 842     } else if (*value == native->math_floor_fun()) {
 843       return typer_->number_fun1_;
 844     } else if (*value == native->math_imul_fun()) {
 845       return typer_->imul_fun_;
 846     } else if (*value == native->math_log_fun()) {
 847       return typer_->number_fun1_;
 848     } else if (*value == native->math_pow_fun()) {
 849       return typer_->number_fun2_;
 850     } else if (*value == native->math_random_fun()) {
 851       return typer_->number_fun0_;
 852     } else if (*value == native->math_round_fun()) {
 853       return typer_->number_fun1_;
 854     } else if (*value == native->math_sin_fun()) {
 855       return typer_->number_fun1_;
 856     } else if (*value == native->math_sqrt_fun()) {
 857       return typer_->number_fun1_;
 858     } else if (*value == native->math_tan_fun()) {
 859       return typer_->number_fun1_;
 860     } else if (*value == native->array_buffer_fun()) {
 861       return typer_->array_buffer_fun_;
 862     } else if (*value == native->int8_array_fun()) {
 863       return typer_->int8_array_fun_;
 864     } else if (*value == native->int16_array_fun()) {
 865       return typer_->int16_array_fun_;
 866     } else if (*value == native->int32_array_fun()) {
 867       return typer_->int32_array_fun_;
 868     } else if (*value == native->uint8_array_fun()) {
 869       return typer_->uint8_array_fun_;
 870     } else if (*value == native->uint16_array_fun()) {
 871       return typer_->uint16_array_fun_;
 872     } else if (*value == native->uint32_array_fun()) {
 873       return typer_->uint32_array_fun_;
 874     } else if (*value == native->float32_array_fun()) {
 875       return typer_->float32_array_fun_;
 876     } else if (*value == native->float64_array_fun()) {
 877       return typer_->float64_array_fun_;
 878     }
 879   }
 880   return Type::Constant(value, zone());
 881 }
 882
 883
 884 namespace {
 885
 886 class TyperDecorator : public GraphDecorator {
 887  public:
 888   explicit TyperDecorator(Typer* typer) : typer_(typer) {}
 889   virtual void Decorate(Node* node) { typer_->Init(node); }
 890
 891  private:
 892   Typer* typer_;
 893 };
 894
 895 }
 896
 897
 898 void Typer::DecorateGraph(Graph* graph) {
 899   graph->AddDecorator(new (zone()) TyperDecorator(this));
 900 }
 901
 902 }
 903 }
 904 }  // namespace v8::internal::compiler