src/compiler/linkage.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/code-stubs.h"
   6 #include "src/compiler.h"
   7 #include "src/compiler/common-operator.h"
   8 #include "src/compiler/frame.h"
   9 #include "src/compiler/linkage.h"
  10 #include "src/compiler/node.h"
  11 #include "src/compiler/osr.h"
  12 #include "src/compiler/pipeline.h"
  13 #include "src/scopes.h"
  14
  15 namespace v8 {
  16 namespace internal {
  17 namespace compiler {
  18
  19 namespace {
  20 LinkageLocation regloc(Register reg) {
  21   return LinkageLocation::ForRegister(Register::ToAllocationIndex(reg));
  22 }
  23
  24
  25 MachineType reptyp(Representation representation) {
  26   switch (representation.kind()) {
  27     case Representation::kInteger8:
  28       return kMachInt8;
  29     case Representation::kUInteger8:
  30       return kMachUint8;
  31     case Representation::kInteger16:
  32       return kMachInt16;
  33     case Representation::kUInteger16:
  34       return kMachUint16;
  35     case Representation::kInteger32:
  36       return kMachInt32;
  37     case Representation::kSmi:
  38     case Representation::kTagged:
  39     case Representation::kHeapObject:
  40       return kMachAnyTagged;
  41     case Representation::kDouble:
  42       return kMachFloat64;
  43     case Representation::kExternal:
  44       return kMachPtr;
  45     case Representation::kNone:
  46     case Representation::kNumRepresentations:
  47       break;
  48   }
  49   UNREACHABLE();
  50   return kMachNone;
  51 }
  52 }  // namespace
  53
  54
  55 std::ostream& operator<<(std::ostream& os, const CallDescriptor::Kind& k) {
  56   switch (k) {
  57     case CallDescriptor::kCallCodeObject:
  58       os << "Code";
  59       break;
  60     case CallDescriptor::kCallJSFunction:
  61       os << "JS";
  62       break;
  63     case CallDescriptor::kCallAddress:
  64       os << "Addr";
  65       break;
  66   }
  67   return os;
  68 }
  69
  70
  71 std::ostream& operator<<(std::ostream& os, const CallDescriptor& d) {
  72   // TODO(svenpanne) Output properties etc. and be less cryptic.
  73   return os << d.kind() << ":" << d.debug_name() << ":r" << d.ReturnCount()
  74             << "s" << d.StackParameterCount() << "i" << d.InputCount() << "f"
  75             << d.FrameStateCount() << "t" << d.SupportsTailCalls();
  76 }
  77
  78
  79 bool CallDescriptor::HasSameReturnLocationsAs(
  80     const CallDescriptor* other) const {
  81   if (ReturnCount() != other->ReturnCount()) return false;
  82   for (size_t i = 0; i < ReturnCount(); ++i) {
  83     if (GetReturnLocation(i) != other->GetReturnLocation(i)) return false;
  84   }
  85   return true;
  86 }
  87
  88
  89 bool CallDescriptor::CanTailCall(const Node* node) const {
  90   // Determine the number of stack parameters passed in
  91   size_t stack_params = 0;
  92   for (size_t i = 0; i < InputCount(); ++i) {
  93     if (!GetInputLocation(i).IsRegister()) {
  94       ++stack_params;
  95     }
  96   }
  97   // Ensure the input linkage contains the stack parameters in the right order
  98   size_t current_stack_param = 0;
  99   for (size_t i = 0; i < InputCount(); ++i) {
 100     if (!GetInputLocation(i).IsRegister()) {
 101       if (GetInputLocation(i) != LinkageLocation::ForCallerFrameSlot(
 102                                      static_cast<int>(current_stack_param) -
 103                                      static_cast<int>(stack_params))) {
 104         return false;
 105       }
 106       ++current_stack_param;
 107     }
 108   }
 109   // Tail calling is currently allowed if return locations match and all
 110   // parameters are either in registers or on the stack but match exactly in
 111   // number and content.
 112   CallDescriptor const* other = OpParameter<CallDescriptor const*>(node);
 113   if (!HasSameReturnLocationsAs(other)) return false;
 114   size_t current_input = 0;
 115   size_t other_input = 0;
 116   while (true) {
 117     if (other_input >= other->InputCount()) {
 118       while (current_input < InputCount()) {
 119         if (!GetInputLocation(current_input).IsRegister()) {
 120           return false;
 121         }
 122         ++current_input;
 123       }
 124       return true;
 125     }
 126     if (current_input >= InputCount()) {
 127       while (other_input < other->InputCount()) {
 128         if (!other->GetInputLocation(other_input).IsRegister()) {
 129           return false;
 130         }
 131         ++other_input;
 132       }
 133       return true;
 134     }
 135     if (GetInputLocation(current_input).IsRegister()) {
 136       ++current_input;
 137       continue;
 138     }
 139     if (other->GetInputLocation(other_input).IsRegister()) {
 140       ++other_input;
 141       continue;
 142     }
 143     if (GetInputLocation(current_input) !=
 144         other->GetInputLocation(other_input)) {
 145       return false;
 146     }
 147     Node* input = node->InputAt(static_cast<int>(other_input));
 148     if (input->opcode() != IrOpcode::kParameter) {
 149       return false;
 150     }
 151     // Make sure that the parameter input passed through to the tail call
 152     // corresponds to the correct stack slot.
 153     size_t param_index = ParameterIndexOf(input->op());
 154     if (param_index != current_input - 1) {
 155       return false;
 156     }
 157     ++current_input;
 158     ++other_input;
 159   }
 160   UNREACHABLE();
 161   return false;
 162 }
 163
 164
 165 CallDescriptor* Linkage::ComputeIncoming(Zone* zone, CompilationInfo* info) {
 166   if (info->code_stub() != NULL) {
 167     // Use the code stub interface descriptor.
 168     CodeStub* stub = info->code_stub();
 169     CallInterfaceDescriptor descriptor = stub->GetCallInterfaceDescriptor();
 170     return GetStubCallDescriptor(
 171         info->isolate(), zone, descriptor, stub->GetStackParameterCount(),
 172         CallDescriptor::kNoFlags, Operator::kNoProperties);
 173   }
 174   if (info->has_literal()) {
 175     // If we already have the function literal, use the number of parameters
 176     // plus the receiver.
 177     return GetJSCallDescriptor(zone, info->is_osr(),
 178                                1 + info->literal()->parameter_count(),
 179                                CallDescriptor::kNoFlags);
 180   }
 181   if (!info->closure().is_null()) {
 182     // If we are compiling a JS function, use a JS call descriptor,
 183     // plus the receiver.
 184     SharedFunctionInfo* shared = info->closure()->shared();
 185     return GetJSCallDescriptor(zone, info->is_osr(),
 186                                1 + shared->internal_formal_parameter_count(),
 187                                CallDescriptor::kNoFlags);
 188   }
 189   return NULL;  // TODO(titzer): ?
 190 }
 191
 192
 193 FrameOffset Linkage::GetFrameOffset(int spill_slot, Frame* frame) const {
 194   bool has_frame = frame->GetSpillSlotCount() > 0 ||
 195                    incoming_->IsJSFunctionCall() ||
 196                    incoming_->kind() == CallDescriptor::kCallAddress;
 197   const int offset =
 198       (StandardFrameConstants::kFixedSlotCountAboveFp - spill_slot - 1) *
 199       kPointerSize;
 200   if (has_frame) {
 201     return FrameOffset::FromFramePointer(offset);
 202   } else {
 203     // No frame. Retrieve all parameters relative to stack pointer.
 204     DCHECK(spill_slot < 0);  // Must be a parameter.
 205     int offsetSpToFp =
 206         kPointerSize * (StandardFrameConstants::kFixedSlotCountAboveFp -
 207                         frame->GetTotalFrameSlotCount());
 208     return FrameOffset::FromStackPointer(offset - offsetSpToFp);
 209   }
 210 }
 211
 212
 213 // static
 214 int Linkage::FrameStateInputCount(Runtime::FunctionId function) {
 215   // Most runtime functions need a FrameState. A few chosen ones that we know
 216   // not to call into arbitrary JavaScript, not to throw, and not to deoptimize
 217   // are blacklisted here and can be called without a FrameState.
 218   switch (function) {
 219     case Runtime::kAllocateInTargetSpace:
 220     case Runtime::kDateField:
 221     case Runtime::kFinalizeClassDefinition:        // TODO(conradw): Is it safe?
 222     case Runtime::kDefineClassMethod:              // TODO(jarin): Is it safe?
 223     case Runtime::kDefineGetterPropertyUnchecked:  // TODO(jarin): Is it safe?
 224     case Runtime::kDefineSetterPropertyUnchecked:  // TODO(jarin): Is it safe?
 225     case Runtime::kForInDone:
 226     case Runtime::kForInStep:
 227     case Runtime::kGetOriginalConstructor:
 228     case Runtime::kNewArguments:
 229     case Runtime::kNewClosure:
 230     case Runtime::kNewFunctionContext:
 231     case Runtime::kNewRestParamSlow:
 232     case Runtime::kPushBlockContext:
 233     case Runtime::kPushCatchContext:
 234     case Runtime::kReThrow:
 235     case Runtime::kStringCompare:
 236     case Runtime::kStringEquals:
 237     case Runtime::kToFastProperties:  // TODO(jarin): Is it safe?
 238     case Runtime::kTraceEnter:
 239     case Runtime::kTraceExit:
 240       return 0;
 241     case Runtime::kInlineArguments:
 242     case Runtime::kInlineCallFunction:
 243     case Runtime::kInlineDefaultConstructorCallSuper:
 244     case Runtime::kInlineGetCallerJSFunction:
 245     case Runtime::kInlineGetPrototype:
 246     case Runtime::kInlineRegExpExec:
 247     case Runtime::kInlineToObject:
 248     case Runtime::kInlineToPrimitive:
 249     case Runtime::kInlineToPrimitive_Number:
 250     case Runtime::kInlineToPrimitive_String:
 251     case Runtime::kInlineOrdinaryToPrimitive:
 252     case Runtime::kInlineToNumber:
 253     case Runtime::kInlineToName:
 254       return 1;
 255     case Runtime::kInlineDeoptimizeNow:
 256     case Runtime::kInlineThrowNotDateError:
 257       return 2;
 258     default:
 259       break;
 260   }
 261
 262   // Most inlined runtime functions (except the ones listed above) can be called
 263   // without a FrameState or will be lowered by JSIntrinsicLowering internally.
 264   const Runtime::Function* const f = Runtime::FunctionForId(function);
 265   if (f->intrinsic_type == Runtime::IntrinsicType::INLINE) return 0;
 266
 267   return 1;
 268 }
 269
 270
 271 bool CallDescriptor::UsesOnlyRegisters() const {
 272   for (size_t i = 0; i < InputCount(); ++i) {
 273     if (!GetInputLocation(i).IsRegister()) return false;
 274   }
 275   for (size_t i = 0; i < ReturnCount(); ++i) {
 276     if (!GetReturnLocation(i).IsRegister()) return false;
 277   }
 278   return true;
 279 }
 280
 281
 282 CallDescriptor* Linkage::GetRuntimeCallDescriptor(
 283     Zone* zone, Runtime::FunctionId function_id, int js_parameter_count,
 284     Operator::Properties properties) {
 285   const size_t function_count = 1;
 286   const size_t num_args_count = 1;
 287   const size_t context_count = 1;
 288   const size_t parameter_count = function_count +
 289                                  static_cast<size_t>(js_parameter_count) +
 290                                  num_args_count + context_count;
 291
 292   const Runtime::Function* function = Runtime::FunctionForId(function_id);
 293   const size_t return_count = static_cast<size_t>(function->result_size);
 294
 295   LocationSignature::Builder locations(zone, return_count, parameter_count);
 296   MachineSignature::Builder types(zone, return_count, parameter_count);
 297
 298   // Add returns.
 299   if (locations.return_count_ > 0) {
 300     locations.AddReturn(regloc(kReturnRegister0));
 301   }
 302   if (locations.return_count_ > 1) {
 303     locations.AddReturn(regloc(kReturnRegister1));
 304   }
 305   for (size_t i = 0; i < return_count; i++) {
 306     types.AddReturn(kMachAnyTagged);
 307   }
 308
 309   // All parameters to the runtime call go on the stack.
 310   for (int i = 0; i < js_parameter_count; i++) {
 311     locations.AddParam(
 312         LinkageLocation::ForCallerFrameSlot(i - js_parameter_count));
 313     types.AddParam(kMachAnyTagged);
 314   }
 315   // Add runtime function itself.
 316   locations.AddParam(regloc(kRuntimeCallFunctionRegister));
 317   types.AddParam(kMachAnyTagged);
 318
 319   // Add runtime call argument count.
 320   locations.AddParam(regloc(kRuntimeCallArgCountRegister));
 321   types.AddParam(kMachPtr);
 322
 323   // Add context.
 324   locations.AddParam(regloc(kContextRegister));
 325   types.AddParam(kMachAnyTagged);
 326
 327   CallDescriptor::Flags flags = Linkage::FrameStateInputCount(function_id) > 0
 328                                     ? CallDescriptor::kNeedsFrameState
 329                                     : CallDescriptor::kNoFlags;
 330
 331   // The target for runtime calls is a code object.
 332   MachineType target_type = kMachAnyTagged;
 333   LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
 334   return new (zone) CallDescriptor(     // --
 335       CallDescriptor::kCallCodeObject,  // kind
 336       target_type,                      // target MachineType
 337       target_loc,                       // target location
 338       types.Build(),                    // machine_sig
 339       locations.Build(),                // location_sig
 340       js_parameter_count,               // stack_parameter_count
 341       properties,                       // properties
 342       kNoCalleeSaved,                   // callee-saved
 343       kNoCalleeSaved,                   // callee-saved fp
 344       flags,                            // flags
 345       function->name);                  // debug name
 346 }
 347
 348
 349 CallDescriptor* Linkage::GetJSCallDescriptor(Zone* zone, bool is_osr,
 350                                              int js_parameter_count,
 351                                              CallDescriptor::Flags flags) {
 352   const size_t return_count = 1;
 353   const size_t context_count = 1;
 354   const size_t parameter_count = js_parameter_count + context_count;
 355
 356   LocationSignature::Builder locations(zone, return_count, parameter_count);
 357   MachineSignature::Builder types(zone, return_count, parameter_count);
 358
 359   // All JS calls have exactly one return value.
 360   locations.AddReturn(regloc(kReturnRegister0));
 361   types.AddReturn(kMachAnyTagged);
 362
 363   // All parameters to JS calls go on the stack.
 364   for (int i = 0; i < js_parameter_count; i++) {
 365     int spill_slot_index = i - js_parameter_count;
 366     locations.AddParam(LinkageLocation::ForCallerFrameSlot(spill_slot_index));
 367     types.AddParam(kMachAnyTagged);
 368   }
 369   // Add context.
 370   locations.AddParam(regloc(kContextRegister));
 371   types.AddParam(kMachAnyTagged);
 372
 373   // The target for JS function calls is the JSFunction object.
 374   MachineType target_type = kMachAnyTagged;
 375   // TODO(titzer): When entering into an OSR function from unoptimized code,
 376   // the JSFunction is not in a register, but it is on the stack in an
 377   // unaddressable spill slot. We hack this in the OSR prologue. Fix.
 378   LinkageLocation target_loc = regloc(kJSFunctionRegister);
 379   return new (zone) CallDescriptor(     // --
 380       CallDescriptor::kCallJSFunction,  // kind
 381       target_type,                      // target MachineType
 382       target_loc,                       // target location
 383       types.Build(),                    // machine_sig
 384       locations.Build(),                // location_sig
 385       js_parameter_count,               // stack_parameter_count
 386       Operator::kNoProperties,          // properties
 387       kNoCalleeSaved,                   // callee-saved
 388       kNoCalleeSaved,                   // callee-saved fp
 389       CallDescriptor::kCanUseRoots |    // flags
 390           flags,                        // flags
 391       "js-call");
 392 }
 393
 394
 395 CallDescriptor* Linkage::GetInterpreterDispatchDescriptor(Zone* zone) {
 396   MachineSignature::Builder types(zone, 0, 6);
 397   LocationSignature::Builder locations(zone, 0, 6);
 398
 399   // Add registers for fixed parameters passed via interpreter dispatch.
 400   STATIC_ASSERT(0 == Linkage::kInterpreterAccumulatorParameter);
 401   types.AddParam(kMachAnyTagged);
 402   locations.AddParam(regloc(kInterpreterAccumulatorRegister));
 403
 404   STATIC_ASSERT(1 == Linkage::kInterpreterRegisterFileParameter);
 405   types.AddParam(kMachPtr);
 406   locations.AddParam(regloc(kInterpreterRegisterFileRegister));
 407
 408   STATIC_ASSERT(2 == Linkage::kInterpreterBytecodeOffsetParameter);
 409   types.AddParam(kMachIntPtr);
 410   locations.AddParam(regloc(kInterpreterBytecodeOffsetRegister));
 411
 412   STATIC_ASSERT(3 == Linkage::kInterpreterBytecodeArrayParameter);
 413   types.AddParam(kMachAnyTagged);
 414   locations.AddParam(regloc(kInterpreterBytecodeArrayRegister));
 415
 416   STATIC_ASSERT(4 == Linkage::kInterpreterDispatchTableParameter);
 417   types.AddParam(kMachPtr);
 418   locations.AddParam(regloc(kInterpreterDispatchTableRegister));
 419
 420   STATIC_ASSERT(5 == Linkage::kInterpreterContextParameter);
 421   types.AddParam(kMachAnyTagged);
 422 #if defined(V8_TARGET_ARCH_IA32) || defined(V8_TARGET_ARCH_X87)
 423   locations.AddParam(
 424       LinkageLocation::ForCallerFrameSlot(kInterpreterContextSpillSlot));
 425 #else
 426   locations.AddParam(regloc(kContextRegister));
 427 #endif
 428
 429   LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
 430   return new (zone) CallDescriptor(         // --
 431       CallDescriptor::kCallCodeObject,      // kind
 432       kMachNone,                            // target MachineType
 433       target_loc,                           // target location
 434       types.Build(),                        // machine_sig
 435       locations.Build(),                    // location_sig
 436       0,                                    // stack_parameter_count
 437       Operator::kNoProperties,              // properties
 438       kNoCalleeSaved,                       // callee-saved registers
 439       kNoCalleeSaved,                       // callee-saved fp regs
 440       CallDescriptor::kSupportsTailCalls |  // flags
 441           CallDescriptor::kCanUseRoots,     // flags
 442       "interpreter-dispatch");
 443 }
 444
 445
 446 // TODO(all): Add support for return representations/locations to
 447 // CallInterfaceDescriptor.
 448 // TODO(turbofan): cache call descriptors for code stub calls.
 449 CallDescriptor* Linkage::GetStubCallDescriptor(
 450     Isolate* isolate, Zone* zone, const CallInterfaceDescriptor& descriptor,
 451     int stack_parameter_count, CallDescriptor::Flags flags,
 452     Operator::Properties properties, MachineType return_type) {
 453   const int register_parameter_count = descriptor.GetRegisterParameterCount();
 454   const int js_parameter_count =
 455       register_parameter_count + stack_parameter_count;
 456   const int context_count = 1;
 457   const size_t return_count = 1;
 458   const size_t parameter_count =
 459       static_cast<size_t>(js_parameter_count + context_count);
 460
 461   LocationSignature::Builder locations(zone, return_count, parameter_count);
 462   MachineSignature::Builder types(zone, return_count, parameter_count);
 463
 464   // Add return location.
 465   locations.AddReturn(regloc(kReturnRegister0));
 466   types.AddReturn(return_type);
 467
 468   // Add parameters in registers and on the stack.
 469   for (int i = 0; i < js_parameter_count; i++) {
 470     if (i < register_parameter_count) {
 471       // The first parameters go in registers.
 472       Register reg = descriptor.GetRegisterParameter(i);
 473       Representation rep =
 474           RepresentationFromType(descriptor.GetParameterType(i));
 475       locations.AddParam(regloc(reg));
 476       types.AddParam(reptyp(rep));
 477     } else {
 478       // The rest of the parameters go on the stack.
 479       int stack_slot = i - register_parameter_count - stack_parameter_count;
 480       locations.AddParam(LinkageLocation::ForCallerFrameSlot(stack_slot));
 481       types.AddParam(kMachAnyTagged);
 482     }
 483   }
 484   // Add context.
 485   locations.AddParam(regloc(kContextRegister));
 486   types.AddParam(kMachAnyTagged);
 487
 488   // The target for stub calls is a code object.
 489   MachineType target_type = kMachAnyTagged;
 490   LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
 491   return new (zone) CallDescriptor(     // --
 492       CallDescriptor::kCallCodeObject,  // kind
 493       target_type,                      // target MachineType
 494       target_loc,                       // target location
 495       types.Build(),                    // machine_sig
 496       locations.Build(),                // location_sig
 497       stack_parameter_count,            // stack_parameter_count
 498       properties,                       // properties
 499       kNoCalleeSaved,                   // callee-saved registers
 500       kNoCalleeSaved,                   // callee-saved fp
 501       flags,                            // flags
 502       descriptor.DebugName(isolate));
 503 }
 504
 505
 506 LinkageLocation Linkage::GetOsrValueLocation(int index) const {
 507   CHECK(incoming_->IsJSFunctionCall());
 508   int parameter_count = static_cast<int>(incoming_->JSParameterCount() - 1);
 509   int first_stack_slot = OsrHelper::FirstStackSlotIndex(parameter_count);
 510
 511   if (index == kOsrContextSpillSlotIndex) {
 512     // Context. Use the parameter location of the context spill slot.
 513     // Parameter (arity + 1) is special for the context of the function frame.
 514     int context_index = 1 + 1 + parameter_count;  // target + receiver + params
 515     return incoming_->GetInputLocation(context_index);
 516   } else if (index >= first_stack_slot) {
 517     // Local variable stored in this (callee) stack.
 518     int spill_index =
 519         index - first_stack_slot + StandardFrameConstants::kFixedSlotCount;
 520     return LinkageLocation::ForCalleeFrameSlot(spill_index);
 521   } else {
 522     // Parameter. Use the assigned location from the incoming call descriptor.
 523     int parameter_index = 1 + index;  // skip index 0, which is the target.
 524     return incoming_->GetInputLocation(parameter_index);
 525   }
 526 }
 527 }  // namespace compiler
 528 }  // namespace internal
 529 }  // namespace v8