js/src/jit/KnownClass.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "jit/KnownClass.h"
   8
   9 #include "jit/MIR.h"
  10 #include "vm/ArrayObject.h"
  11 #include "vm/Iteration.h"
  12 #include "vm/JSFunction.h"
  13 #include "vm/PlainObject.h"  // js::PlainObject
  14 #include "vm/RegExpObject.h"
  15
  16 using namespace js;
  17 using namespace js::jit;
  18
  19 KnownClass jit::GetObjectKnownClass(const MDefinition* def) {
  20   MOZ_ASSERT(def->type() == MIRType::Object);
  21
  22   switch (def->op()) {
  23     case MDefinition::Opcode::NewArray:
  24     case MDefinition::Opcode::NewArrayDynamicLength:
  25     case MDefinition::Opcode::NewArrayObject:
  26     case MDefinition::Opcode::Rest:
  27     case MDefinition::Opcode::ArgumentsSlice:
  28     case MDefinition::Opcode::FrameArgumentsSlice:
  29     case MDefinition::Opcode::InlineArgumentsSlice:
  30       return KnownClass::Array;
  31
  32     case MDefinition::Opcode::NewObject:
  33     case MDefinition::Opcode::NewPlainObject:
  34     case MDefinition::Opcode::CreateThis:
  35       return KnownClass::PlainObject;
  36
  37     case MDefinition::Opcode::Lambda:
  38     case MDefinition::Opcode::FunctionWithProto:
  39       return KnownClass::Function;
  40
  41     case MDefinition::Opcode::RegExp:
  42       return KnownClass::RegExp;
  43
  44     case MDefinition::Opcode::NewIterator:
  45       switch (def->toNewIterator()->type()) {
  46         case MNewIterator::ArrayIterator:
  47           return KnownClass::ArrayIterator;
  48         case MNewIterator::StringIterator:
  49           return KnownClass::StringIterator;
  50         case MNewIterator::RegExpStringIterator:
  51           return KnownClass::RegExpStringIterator;
  52       }
  53       MOZ_CRASH("unreachable");
  54
  55     case MDefinition::Opcode::Phi: {
  56       if (def->numOperands() == 0) {
  57         return KnownClass::None;
  58       }
  59
  60       MDefinition* op = def->getOperand(0);
  61       // Check for Phis to avoid recursion for now.
  62       if (op->isPhi()) {
  63         return KnownClass::None;
  64       }
  65
  66       KnownClass known = GetObjectKnownClass(op);
  67       if (known == KnownClass::None) {
  68         return KnownClass::None;
  69       }
  70
  71       for (size_t i = 1; i < def->numOperands(); i++) {
  72         op = def->getOperand(i);
  73         if (op->isPhi() || GetObjectKnownClass(op) != known) {
  74           return KnownClass::None;
  75         }
  76       }
  77
  78       return known;
  79     }
  80
  81     default:
  82       break;
  83   }
  84
  85   return KnownClass::None;
  86 }
  87
  88 const JSClass* jit::GetObjectKnownJSClass(const MDefinition* def) {
  89   switch (GetObjectKnownClass(def)) {
  90     case KnownClass::PlainObject:
  91       return &PlainObject::class_;
  92     case KnownClass::Array:
  93       return &ArrayObject::class_;
  94     case KnownClass::Function:
  95       return &FunctionClass;
  96     case KnownClass::RegExp:
  97       return &RegExpObject::class_;
  98     case KnownClass::ArrayIterator:
  99       return &ArrayIteratorObject::class_;
 100     case KnownClass::StringIterator:
 101       return &StringIteratorObject::class_;
 102     case KnownClass::RegExpStringIterator:
 103       return &RegExpStringIteratorObject::class_;
 104     case KnownClass::None:
 105       break;
 106   }
 107
 108   return nullptr;
 109 }