Home | History | Annotate | Download | only in compiler 
      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/code-factory.h"
      6 #include "src/code-stubs.h"
      7 #include "src/compiler/common-operator.h"
      8 #include "src/compiler/graph-inl.h"
      9 #include "src/compiler/js-generic-lowering.h"
     10 #include "src/compiler/machine-operator.h"
     11 #include "src/compiler/node-aux-data-inl.h"
     12 #include "src/compiler/node-properties-inl.h"
     13 #include "src/unique.h"
     14 
     15 namespace v8 {
     16 namespace internal {
     17 namespace compiler {
     18 
     19 JSGenericLowering::JSGenericLowering(CompilationInfo* info, JSGraph* jsgraph)
     20     : info_(info),
     21       jsgraph_(jsgraph),
     22       linkage_(new (jsgraph->zone()) Linkage(info)) {}
     23 
     24 
     25 void JSGenericLowering::PatchOperator(Node* node, const Operator* op) {
     26   node->set_op(op);
     27 }
     28 
     29 
     30 void JSGenericLowering::PatchInsertInput(Node* node, int index, Node* input) {
     31   node->InsertInput(zone(), index, input);
     32 }
     33 
     34 
     35 Node* JSGenericLowering::SmiConstant(int32_t immediate) {
     36   return jsgraph()->SmiConstant(immediate);
     37 }
     38 
     39 
     40 Node* JSGenericLowering::Int32Constant(int immediate) {
     41   return jsgraph()->Int32Constant(immediate);
     42 }
     43 
     44 
     45 Node* JSGenericLowering::CodeConstant(Handle<Code> code) {
     46   return jsgraph()->HeapConstant(code);
     47 }
     48 
     49 
     50 Node* JSGenericLowering::FunctionConstant(Handle<JSFunction> function) {
     51   return jsgraph()->HeapConstant(function);
     52 }
     53 
     54 
     55 Node* JSGenericLowering::ExternalConstant(ExternalReference ref) {
     56   return jsgraph()->ExternalConstant(ref);
     57 }
     58 
     59 
     60 Reduction JSGenericLowering::Reduce(Node* node) {
     61   switch (node->opcode()) {
     62 #define DECLARE_CASE(x) \
     63   case IrOpcode::k##x:  \
     64     Lower##x(node);     \
     65     break;
     66     DECLARE_CASE(Branch)
     67     JS_OP_LIST(DECLARE_CASE)
     68 #undef DECLARE_CASE
     69     default:
     70       // Nothing to see.
     71       return NoChange();
     72   }
     73   return Changed(node);
     74 }
     75 
     76 
     77 #define REPLACE_BINARY_OP_IC_CALL(op, token)                             \
     78   void JSGenericLowering::Lower##op(Node* node) {                        \
     79     ReplaceWithStubCall(node, CodeFactory::BinaryOpIC(isolate(), token), \
     80                         CallDescriptor::kPatchableCallSiteWithNop);      \
     81   }
     82 REPLACE_BINARY_OP_IC_CALL(JSBitwiseOr, Token::BIT_OR)
     83 REPLACE_BINARY_OP_IC_CALL(JSBitwiseXor, Token::BIT_XOR)
     84 REPLACE_BINARY_OP_IC_CALL(JSBitwiseAnd, Token::BIT_AND)
     85 REPLACE_BINARY_OP_IC_CALL(JSShiftLeft, Token::SHL)
     86 REPLACE_BINARY_OP_IC_CALL(JSShiftRight, Token::SAR)
     87 REPLACE_BINARY_OP_IC_CALL(JSShiftRightLogical, Token::SHR)
     88 REPLACE_BINARY_OP_IC_CALL(JSAdd, Token::ADD)
     89 REPLACE_BINARY_OP_IC_CALL(JSSubtract, Token::SUB)
     90 REPLACE_BINARY_OP_IC_CALL(JSMultiply, Token::MUL)
     91 REPLACE_BINARY_OP_IC_CALL(JSDivide, Token::DIV)
     92 REPLACE_BINARY_OP_IC_CALL(JSModulus, Token::MOD)
     93 #undef REPLACE_BINARY_OP_IC_CALL
     94 
     95 
     96 #define REPLACE_COMPARE_IC_CALL(op, token, pure)  \
     97   void JSGenericLowering::Lower##op(Node* node) { \
     98     ReplaceWithCompareIC(node, token, pure);      \
     99   }
    100 REPLACE_COMPARE_IC_CALL(JSEqual, Token::EQ, false)
    101 REPLACE_COMPARE_IC_CALL(JSNotEqual, Token::NE, false)
    102 REPLACE_COMPARE_IC_CALL(JSStrictEqual, Token::EQ_STRICT, true)
    103 REPLACE_COMPARE_IC_CALL(JSStrictNotEqual, Token::NE_STRICT, true)
    104 REPLACE_COMPARE_IC_CALL(JSLessThan, Token::LT, false)
    105 REPLACE_COMPARE_IC_CALL(JSGreaterThan, Token::GT, false)
    106 REPLACE_COMPARE_IC_CALL(JSLessThanOrEqual, Token::LTE, false)
    107 REPLACE_COMPARE_IC_CALL(JSGreaterThanOrEqual, Token::GTE, false)
    108 #undef REPLACE_COMPARE_IC_CALL
    109 
    110 
    111 #define REPLACE_RUNTIME_CALL(op, fun)             \
    112   void JSGenericLowering::Lower##op(Node* node) { \
    113     ReplaceWithRuntimeCall(node, fun);            \
    114   }
    115 REPLACE_RUNTIME_CALL(JSTypeOf, Runtime::kTypeof)
    116 REPLACE_RUNTIME_CALL(JSCreate, Runtime::kAbort)
    117 REPLACE_RUNTIME_CALL(JSCreateFunctionContext, Runtime::kNewFunctionContext)
    118 REPLACE_RUNTIME_CALL(JSCreateCatchContext, Runtime::kPushCatchContext)
    119 REPLACE_RUNTIME_CALL(JSCreateWithContext, Runtime::kPushWithContext)
    120 REPLACE_RUNTIME_CALL(JSCreateBlockContext, Runtime::kPushBlockContext)
    121 REPLACE_RUNTIME_CALL(JSCreateModuleContext, Runtime::kPushModuleContext)
    122 REPLACE_RUNTIME_CALL(JSCreateGlobalContext, Runtime::kAbort)
    123 #undef REPLACE_RUNTIME
    124 
    125 
    126 #define REPLACE_UNIMPLEMENTED(op) \
    127   void JSGenericLowering::Lower##op(Node* node) { UNIMPLEMENTED(); }
    128 REPLACE_UNIMPLEMENTED(JSToName)
    129 REPLACE_UNIMPLEMENTED(JSYield)
    130 REPLACE_UNIMPLEMENTED(JSDebugger)
    131 #undef REPLACE_UNIMPLEMENTED
    132 
    133 
    134 static CallDescriptor::Flags FlagsForNode(Node* node) {
    135   CallDescriptor::Flags result = CallDescriptor::kNoFlags;
    136   if (OperatorProperties::HasFrameStateInput(node->op())) {
    137     result |= CallDescriptor::kNeedsFrameState;
    138   }
    139   return result;
    140 }
    141 
    142 
    143 void JSGenericLowering::ReplaceWithCompareIC(Node* node, Token::Value token,
    144                                              bool pure) {
    145   Callable callable = CodeFactory::CompareIC(isolate(), token);
    146   bool has_frame_state = OperatorProperties::HasFrameStateInput(node->op());
    147   CallDescriptor* desc_compare = linkage()->GetStubCallDescriptor(
    148       callable.descriptor(), 0,
    149       CallDescriptor::kPatchableCallSiteWithNop | FlagsForNode(node));
    150   NodeVector inputs(zone());
    151   inputs.reserve(node->InputCount() + 1);
    152   inputs.push_back(CodeConstant(callable.code()));
    153   inputs.push_back(NodeProperties::GetValueInput(node, 0));
    154   inputs.push_back(NodeProperties::GetValueInput(node, 1));
    155   inputs.push_back(NodeProperties::GetContextInput(node));
    156   if (pure) {
    157     // A pure (strict) comparison doesn't have an effect, control or frame
    158     // state.  But for the graph, we need to add control and effect inputs.
    159     DCHECK(!has_frame_state);
    160     inputs.push_back(graph()->start());
    161     inputs.push_back(graph()->start());
    162   } else {
    163     DCHECK(has_frame_state == FLAG_turbo_deoptimization);
    164     if (FLAG_turbo_deoptimization) {
    165       inputs.push_back(NodeProperties::GetFrameStateInput(node));
    166     }
    167     inputs.push_back(NodeProperties::GetEffectInput(node));
    168     inputs.push_back(NodeProperties::GetControlInput(node));
    169   }
    170   Node* compare =
    171       graph()->NewNode(common()->Call(desc_compare),
    172                        static_cast<int>(inputs.size()), &inputs.front());
    173 
    174   node->ReplaceInput(0, compare);
    175   node->ReplaceInput(1, SmiConstant(token));
    176 
    177   if (has_frame_state) {
    178     // Remove the frame state from inputs.
    179     node->RemoveInput(NodeProperties::FirstFrameStateIndex(node));
    180   }
    181 
    182   ReplaceWithRuntimeCall(node, Runtime::kBooleanize);
    183 }
    184 
    185 
    186 void JSGenericLowering::ReplaceWithStubCall(Node* node, Callable callable,
    187                                             CallDescriptor::Flags flags) {
    188   CallDescriptor* desc = linkage()->GetStubCallDescriptor(
    189       callable.descriptor(), 0, flags | FlagsForNode(node));
    190   Node* stub_code = CodeConstant(callable.code());
    191   PatchInsertInput(node, 0, stub_code);
    192   PatchOperator(node, common()->Call(desc));
    193 }
    194 
    195 
    196 void JSGenericLowering::ReplaceWithBuiltinCall(Node* node,
    197                                                Builtins::JavaScript id,
    198                                                int nargs) {
    199   Callable callable =
    200       CodeFactory::CallFunction(isolate(), nargs - 1, NO_CALL_FUNCTION_FLAGS);
    201   CallDescriptor* desc =
    202       linkage()->GetStubCallDescriptor(callable.descriptor(), nargs);
    203   // TODO(mstarzinger): Accessing the builtins object this way prevents sharing
    204   // of code across native contexts. Fix this by loading from given context.
    205   Handle<JSFunction> function(
    206       JSFunction::cast(info()->context()->builtins()->javascript_builtin(id)));
    207   Node* stub_code = CodeConstant(callable.code());
    208   Node* function_node = FunctionConstant(function);
    209   PatchInsertInput(node, 0, stub_code);
    210   PatchInsertInput(node, 1, function_node);
    211   PatchOperator(node, common()->Call(desc));
    212 }
    213 
    214 
    215 void JSGenericLowering::ReplaceWithRuntimeCall(Node* node,
    216                                                Runtime::FunctionId f,
    217                                                int nargs_override) {
    218   Operator::Properties properties = node->op()->properties();
    219   const Runtime::Function* fun = Runtime::FunctionForId(f);
    220   int nargs = (nargs_override < 0) ? fun->nargs : nargs_override;
    221   CallDescriptor* desc =
    222       linkage()->GetRuntimeCallDescriptor(f, nargs, properties);
    223   Node* ref = ExternalConstant(ExternalReference(f, isolate()));
    224   Node* arity = Int32Constant(nargs);
    225   if (!centrystub_constant_.is_set()) {
    226     centrystub_constant_.set(CodeConstant(CEntryStub(isolate(), 1).GetCode()));
    227   }
    228   PatchInsertInput(node, 0, centrystub_constant_.get());
    229   PatchInsertInput(node, nargs + 1, ref);
    230   PatchInsertInput(node, nargs + 2, arity);
    231   PatchOperator(node, common()->Call(desc));
    232 }
    233 
    234 
    235 void JSGenericLowering::LowerBranch(Node* node) {
    236   if (!info()->is_typing_enabled()) {
    237     // TODO(mstarzinger): If typing is enabled then simplified lowering will
    238     // have inserted the correct ChangeBoolToBit, otherwise we need to perform
    239     // poor-man's representation inference here and insert manual change.
    240     Node* test = graph()->NewNode(machine()->WordEqual(), node->InputAt(0),
    241                                   jsgraph()->TrueConstant());
    242     node->ReplaceInput(0, test);
    243   }
    244 }
    245 
    246 
    247 void JSGenericLowering::LowerJSUnaryNot(Node* node) {
    248   Callable callable = CodeFactory::ToBoolean(
    249       isolate(), ToBooleanStub::RESULT_AS_INVERSE_ODDBALL);
    250   ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
    251 }
    252 
    253 
    254 void JSGenericLowering::LowerJSToBoolean(Node* node) {
    255   Callable callable =
    256       CodeFactory::ToBoolean(isolate(), ToBooleanStub::RESULT_AS_ODDBALL);
    257   ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
    258 }
    259 
    260 
    261 void JSGenericLowering::LowerJSToNumber(Node* node) {
    262   Callable callable = CodeFactory::ToNumber(isolate());
    263   ReplaceWithStubCall(node, callable, CallDescriptor::kNoFlags);
    264 }
    265 
    266 
    267 void JSGenericLowering::LowerJSToString(Node* node) {
    268   ReplaceWithBuiltinCall(node, Builtins::TO_STRING, 1);
    269 }
    270 
    271 
    272 void JSGenericLowering::LowerJSToObject(Node* node) {
    273   ReplaceWithBuiltinCall(node, Builtins::TO_OBJECT, 1);
    274 }
    275 
    276 
    277 void JSGenericLowering::LowerJSLoadProperty(Node* node) {
    278   Callable callable = CodeFactory::KeyedLoadIC(isolate());
    279   ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
    280 }
    281 
    282 
    283 void JSGenericLowering::LowerJSLoadNamed(Node* node) {
    284   LoadNamedParameters p = OpParameter<LoadNamedParameters>(node);
    285   Callable callable = CodeFactory::LoadIC(isolate(), p.contextual_mode);
    286   PatchInsertInput(node, 1, jsgraph()->HeapConstant(p.name));
    287   ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
    288 }
    289 
    290 
    291 void JSGenericLowering::LowerJSStoreProperty(Node* node) {
    292   StrictMode strict_mode = OpParameter<StrictMode>(node);
    293   Callable callable = CodeFactory::KeyedStoreIC(isolate(), strict_mode);
    294   ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
    295 }
    296 
    297 
    298 void JSGenericLowering::LowerJSStoreNamed(Node* node) {
    299   StoreNamedParameters params = OpParameter<StoreNamedParameters>(node);
    300   Callable callable = CodeFactory::StoreIC(isolate(), params.strict_mode);
    301   PatchInsertInput(node, 1, jsgraph()->HeapConstant(params.name));
    302   ReplaceWithStubCall(node, callable, CallDescriptor::kPatchableCallSite);
    303 }
    304 
    305 
    306 void JSGenericLowering::LowerJSDeleteProperty(Node* node) {
    307   StrictMode strict_mode = OpParameter<StrictMode>(node);
    308   PatchInsertInput(node, 2, SmiConstant(strict_mode));
    309   ReplaceWithBuiltinCall(node, Builtins::DELETE, 3);
    310 }
    311 
    312 
    313 void JSGenericLowering::LowerJSHasProperty(Node* node) {
    314   ReplaceWithBuiltinCall(node, Builtins::IN, 2);
    315 }
    316 
    317 
    318 void JSGenericLowering::LowerJSInstanceOf(Node* node) {
    319   InstanceofStub::Flags flags = static_cast<InstanceofStub::Flags>(
    320       InstanceofStub::kReturnTrueFalseObject |
    321       InstanceofStub::kArgsInRegisters);
    322   InstanceofStub stub(isolate(), flags);
    323   CallInterfaceDescriptor d = stub.GetCallInterfaceDescriptor();
    324   CallDescriptor* desc = linkage()->GetStubCallDescriptor(d, 0);
    325   Node* stub_code = CodeConstant(stub.GetCode());
    326   PatchInsertInput(node, 0, stub_code);
    327   PatchOperator(node, common()->Call(desc));
    328 }
    329 
    330 
    331 void JSGenericLowering::LowerJSLoadContext(Node* node) {
    332   ContextAccess access = OpParameter<ContextAccess>(node);
    333   // TODO(mstarzinger): Use simplified operators instead of machine operators
    334   // here so that load/store optimization can be applied afterwards.
    335   for (int i = 0; i < access.depth(); ++i) {
    336     node->ReplaceInput(
    337         0, graph()->NewNode(
    338                machine()->Load(kMachAnyTagged),
    339                NodeProperties::GetValueInput(node, 0),
    340                Int32Constant(Context::SlotOffset(Context::PREVIOUS_INDEX)),
    341                NodeProperties::GetEffectInput(node)));
    342   }
    343   node->ReplaceInput(1, Int32Constant(Context::SlotOffset(access.index())));
    344   PatchOperator(node, machine()->Load(kMachAnyTagged));
    345 }
    346 
    347 
    348 void JSGenericLowering::LowerJSStoreContext(Node* node) {
    349   ContextAccess access = OpParameter<ContextAccess>(node);
    350   // TODO(mstarzinger): Use simplified operators instead of machine operators
    351   // here so that load/store optimization can be applied afterwards.
    352   for (int i = 0; i < access.depth(); ++i) {
    353     node->ReplaceInput(
    354         0, graph()->NewNode(
    355                machine()->Load(kMachAnyTagged),
    356                NodeProperties::GetValueInput(node, 0),
    357                Int32Constant(Context::SlotOffset(Context::PREVIOUS_INDEX)),
    358                NodeProperties::GetEffectInput(node)));
    359   }
    360   node->ReplaceInput(2, NodeProperties::GetValueInput(node, 1));
    361   node->ReplaceInput(1, Int32Constant(Context::SlotOffset(access.index())));
    362   PatchOperator(node, machine()->Store(StoreRepresentation(kMachAnyTagged,
    363                                                            kFullWriteBarrier)));
    364 }
    365 
    366 
    367 void JSGenericLowering::LowerJSCallConstruct(Node* node) {
    368   int arity = OpParameter<int>(node);
    369   CallConstructStub stub(isolate(), NO_CALL_CONSTRUCTOR_FLAGS);
    370   CallInterfaceDescriptor d = stub.GetCallInterfaceDescriptor();
    371   CallDescriptor* desc =
    372       linkage()->GetStubCallDescriptor(d, arity, FlagsForNode(node));
    373   Node* stub_code = CodeConstant(stub.GetCode());
    374   Node* construct = NodeProperties::GetValueInput(node, 0);
    375   PatchInsertInput(node, 0, stub_code);
    376   PatchInsertInput(node, 1, Int32Constant(arity - 1));
    377   PatchInsertInput(node, 2, construct);
    378   PatchInsertInput(node, 3, jsgraph()->UndefinedConstant());
    379   PatchOperator(node, common()->Call(desc));
    380 }
    381 
    382 
    383 void JSGenericLowering::LowerJSCallFunction(Node* node) {
    384   CallParameters p = OpParameter<CallParameters>(node);
    385   CallFunctionStub stub(isolate(), p.arity - 2, p.flags);
    386   CallInterfaceDescriptor d = stub.GetCallInterfaceDescriptor();
    387   CallDescriptor* desc =
    388       linkage()->GetStubCallDescriptor(d, p.arity - 1, FlagsForNode(node));
    389   Node* stub_code = CodeConstant(stub.GetCode());
    390   PatchInsertInput(node, 0, stub_code);
    391   PatchOperator(node, common()->Call(desc));
    392 }
    393 
    394 
    395 void JSGenericLowering::LowerJSCallRuntime(Node* node) {
    396   Runtime::FunctionId function = OpParameter<Runtime::FunctionId>(node);
    397   int arity = OperatorProperties::GetValueInputCount(node->op());
    398   ReplaceWithRuntimeCall(node, function, arity);
    399 }
    400 
    401 }  // namespace compiler
    402 }  // namespace internal
    403 }  // namespace v8
    404