AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
7a9058618b
v8/src/code-factory.h

194 lines
8.6 KiB
C
Raw Normal View History

Turbofan needs a code handle and a CallInterfaceDescriptor. At the same time we spread knowledge about how to create the initial IC code object too widely. Consolidate code creation and unify it with a descriptor via CodeFactory. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/567433002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23877 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-11 13:18:58 +00:00
// Copyright 2012 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_CODE_FACTORY_H_
#define V8_CODE_FACTORY_H_
#include "src/allocation.h"
#include "src/assembler.h"
[csa] Add CSA::CallBuiltin and Builtins::CallableFor This is another step towards making calls to builtins more convenient. Builtins::CallableFor is an automatically generated Callable accessor for TFS builtins (whereas previously we had to manually add an accessor to code-factory.{h,cc}). CSA::CallBuiltin is a convenience wrapper around CallStub for TFS builtins. We can begin removing accessors for TFS builtins from CodeFactory in an upcoming commit. BUG=v8:5737 Review-Url: https://codereview.chromium.org/2752213002 Cr-Commit-Position: refs/heads/master@{#43865}
2017-03-16 14:22:12 +00:00
#include "src/callable.h"
Turbofan needs a code handle and a CallInterfaceDescriptor. At the same time we spread knowledge about how to create the initial IC code object too widely. Consolidate code creation and unify it with a descriptor via CodeFactory. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/567433002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23877 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-11 13:18:58 +00:00
#include "src/codegen.h"
#include "src/globals.h"
#include "src/interface-descriptors.h"
namespace v8 {
namespace internal {
Make unittests work in component build R=machenbach@chromium.org,titzer@chromium.org,bmeurer@chromium.org,jgruber@chromium.org BUG= CQ_INCLUDE_TRYBOTS=master.tryserver.v8:v8_win_dbg,v8_mac_dbg;master.tryserver.chromium.android:android_arm64_dbg_recipe Review-Url: https://codereview.chromium.org/2416243002 Cr-Commit-Position: refs/heads/master@{#40350}
2016-10-17 10:01:42 +00:00
class V8_EXPORT_PRIVATE CodeFactory final {
Turbofan needs a code handle and a CallInterfaceDescriptor. At the same time we spread knowledge about how to create the initial IC code object too widely. Consolidate code creation and unify it with a descriptor via CodeFactory. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/567433002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23877 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-11 13:18:58 +00:00
public:
[turbofan] Combine family of CallRuntime() methods into single imeplementation. .. by using variadic templates in CodeAssembler and RawMachineAssembler. BUG= Review-Url: https://codereview.chromium.org/2580823002 Cr-Commit-Position: refs/heads/master@{#41733}
2016-12-15 17:18:42 +00:00
// CEntryStub has var-args semantics (all the arguments are passed on the
// stack and the arguments count is passed via register) which currently
// can't be expressed in CallInterfaceDescriptor. Therefore only the code
// is exported here.
static Handle<Code> RuntimeCEntry(Isolate* isolate, int result_size = 1);
Turbofan needs a code handle and a CallInterfaceDescriptor. At the same time we spread knowledge about how to create the initial IC code object too widely. Consolidate code creation and unify it with a descriptor via CodeFactory. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/567433002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23877 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-11 13:18:58 +00:00
// Initial states for ICs.
[ic] Split LoadIC into LoadGlobalIC and LoadIC. The former will handle loads of predeclared global variables (vars and functions), lets, consts and undeclared variables. The latter will handle named loads from explicit receiver. In addition, named loads does not depend of the TypeofMode. TypeofMode related cleanup will be done in the follow-up CL. BUG=chromium:576312 LOG=Y TBR=bmeurer@chromium.org Review-Url: https://codereview.chromium.org/1912633002 Cr-Commit-Position: refs/heads/master@{#36965}
2016-06-14 13:20:42 +00:00
static Callable LoadIC(Isolate* isolate);
[LoadIC] Use LoadIC_Uninitialized for 0->PRE transitions Avoiding runtime call overhead. There's a fast path for Function.prototype loads, which are very common. BUG=v8:5269 Review-Url: https://codereview.chromium.org/2711353002 Cr-Commit-Position: refs/heads/master@{#43474}
2017-02-28 11:04:04 +00:00
static Callable LoadIC_Uninitialized(Isolate* isolate);
[ic] Split LoadIC into LoadGlobalIC and LoadIC. The former will handle loads of predeclared global variables (vars and functions), lets, consts and undeclared variables. The latter will handle named loads from explicit receiver. In addition, named loads does not depend of the TypeofMode. TypeofMode related cleanup will be done in the follow-up CL. BUG=chromium:576312 LOG=Y TBR=bmeurer@chromium.org Review-Url: https://codereview.chromium.org/1912633002 Cr-Commit-Position: refs/heads/master@{#36965}
2016-06-14 13:20:42 +00:00
static Callable LoadICInOptimizedCode(Isolate* isolate);
[ic] Inline LoadIC into LdaNamedProperty bytecode handler This inlines common LoadIC cases into the LdaNamedProperty bytecode handler. Smi handlers resulting in constant/field loads for monomorphic ICs omit frame construction. The same counts for the polymorphic case as long as the target handler is in the first two vector slots. Other cases (megamorphic, uninitialized) call the new LoadIC_Noninlined stub. Local benchmarks show up to 6% improvement on Sunspider with --future. BUG=v8:5917 Review-Url: https://codereview.chromium.org/2733563002 Cr-Commit-Position: refs/heads/master@{#43630}
2017-03-07 10:21:33 +00:00
static Callable LoadICInOptimizedCode_Noninlined(Isolate* isolate);
[ic] Clean up handler boilerplate - builtins-ic.cc takes the place of the AccessorAssembler shim - AccessorAssemblerImpl can then be renamed - some cleanup in code-factory.cc - drop old _TF name suffixes - fix Generate##Name##Impl in TF_BUILTIN macro Review-Url: https://codereview.chromium.org/2647493002 Cr-Commit-Position: refs/heads/master@{#42520}
2017-01-19 18:39:07 +00:00
static Callable LoadICProtoArray(Isolate* isolate, bool throw_if_nonexistent);
[ic] Split LoadIC into LoadGlobalIC and LoadIC. The former will handle loads of predeclared global variables (vars and functions), lets, consts and undeclared variables. The latter will handle named loads from explicit receiver. In addition, named loads does not depend of the TypeofMode. TypeofMode related cleanup will be done in the follow-up CL. BUG=chromium:576312 LOG=Y TBR=bmeurer@chromium.org Review-Url: https://codereview.chromium.org/1912633002 Cr-Commit-Position: refs/heads/master@{#36965}
2016-06-14 13:20:42 +00:00
static Callable LoadGlobalIC(Isolate* isolate, TypeofMode typeof_mode);
static Callable LoadGlobalICInOptimizedCode(Isolate* isolate,
TypeofMode typeof_mode);
Remove strong mode support from property loads. R=rossberg@chromium.org,bmeurer@chromium.org,verwaest@chromium.org BUG=v8:3956 LOG=n Review URL: https://codereview.chromium.org/1700993002 Cr-Commit-Position: refs/heads/master@{#34067}
2016-02-17 10:30:10 +00:00
static Callable KeyedLoadIC(Isolate* isolate);
IC: Eliminate initialization_state as a factor in IC installation. In Crankshaft, we would install special ICs that didn't need a vector and slot in the MEGAMORPHIC case. This optimization limits our hand against future improvements. BUG= Review-Url: https://codereview.chromium.org/2019313003 Cr-Commit-Position: refs/heads/master@{#36597}
2016-05-30 19:26:02 +00:00
static Callable KeyedLoadICInOptimizedCode(Isolate* isolate);
[KeyedLoadIC] Support Smi "handlers" for simple field loads This ports 9c59539f2 / r37803 to KeyedLoadICs. Review-Url: https://codereview.chromium.org/2182103002 Cr-Commit-Position: refs/heads/master@{#38070}
2016-07-26 17:51:25 +00:00
static Callable KeyedLoadIC_Megamorphic(Isolate* isolate);
[stubs] Refactor the CallICStub to pass the number of arguments. This is the next step to unify the Call/Construct feedback collection and prepare it to be able to collect SharedFunctionInfo feedback. This also reduces the CallICStub overhead quite a bit since we only need one stub per mode (and tail call mode), not also one per call arity. R=mvstanton@chromium.org BUG=v8:2206 NOTRY=true Review-Url: https://codereview.chromium.org/2412453005 Cr-Commit-Position: refs/heads/master@{#40206}
2016-10-12 09:25:55 +00:00
static Callable CallIC(Isolate* isolate,
[es6] Tail calls support. This CL implements PrepareForTailCall() mentioned in ES6 spec for full codegen, Crankshaft and Turbofan. When debugger is active tail calls are disabled. Tail calling can be enabled by --harmony-tailcalls flag. BUG=v8:4698 LOG=Y TBR=rossberg@chromium.org Review URL: https://codereview.chromium.org/1609893003 Cr-Commit-Position: refs/heads/master@{#33509}
2016-01-26 11:07:15 +00:00
ConvertReceiverMode mode = ConvertReceiverMode::kAny,
TailCallMode tail_call_mode = TailCallMode::kDisallow);
[stubs] Fix naming of CallIC and CallICTrampoline. Rename the CallIC factory method to CallICTrampoline and the CallICInOptimizedCode to CallIC to match the naming of the stubs and better reflect their functionality. R=yangguo@chromium.org Review-Url: https://codereview.chromium.org/2670073002 Cr-Commit-Position: refs/heads/master@{#42876}
2017-02-02 06:54:27 +00:00
static Callable CallICTrampoline(
[stubs] Refactor the CallICStub to pass the number of arguments. This is the next step to unify the Call/Construct feedback collection and prepare it to be able to collect SharedFunctionInfo feedback. This also reduces the CallICStub overhead quite a bit since we only need one stub per mode (and tail call mode), not also one per call arity. R=mvstanton@chromium.org BUG=v8:2206 NOTRY=true Review-Url: https://codereview.chromium.org/2412453005 Cr-Commit-Position: refs/heads/master@{#40206}
2016-10-12 09:25:55 +00:00
Isolate* isolate, ConvertReceiverMode mode = ConvertReceiverMode::kAny,
[es6] Tail calls support. This CL implements PrepareForTailCall() mentioned in ES6 spec for full codegen, Crankshaft and Turbofan. When debugger is active tail calls are disabled. Tail calling can be enabled by --harmony-tailcalls flag. BUG=v8:4698 LOG=Y TBR=rossberg@chromium.org Review URL: https://codereview.chromium.org/1609893003 Cr-Commit-Position: refs/heads/master@{#33509}
2016-01-26 11:07:15 +00:00
TailCallMode tail_call_mode = TailCallMode::kDisallow);
Introduce LanguageMode, drop StrictMode. This enables adding more language modes in the future. For maximum flexibility, LanguageMode is a bitmask, so we're not restricted to use a sequence of language modes which are progressively stricter, but we can express the language mode as combination of features. For now, LanguageMode can only be "sloppy" or "strict", and there are STATIC_ASSERTS in places which need to change when more modes are added. LanguageMode is a bit like the old LanguageMode when "extended" mode was still around (see https://codereview.chromium.org/8417035 and https://codereview.chromium.org/181543002 ) except that it's transmitted through all the layers (there's no StrictModeFlag). BUG= Review URL: https://codereview.chromium.org/894683003 Cr-Commit-Position: refs/heads/master@{#26419}
2015-02-04 09:34:05 +00:00
static Callable StoreIC(Isolate* isolate, LanguageMode mode);
IC: Eliminate initialization_state as a factor in IC installation. In Crankshaft, we would install special ICs that didn't need a vector and slot in the MEGAMORPHIC case. This optimization limits our hand against future improvements. BUG= Review-Url: https://codereview.chromium.org/2019313003 Cr-Commit-Position: refs/heads/master@{#36597}
2016-05-30 19:26:02 +00:00
static Callable StoreICInOptimizedCode(Isolate* isolate, LanguageMode mode);
[StoreIC] Use StoreIC_Uninitialized for 0->PRE transitions Avoiding runtime call overhead. BUG=v8:5269 Review-Url: https://codereview.chromium.org/2717203002 Cr-Commit-Position: refs/heads/master@{#43799}
2017-03-14 16:59:22 +00:00
static Callable StoreIC_Uninitialized(Isolate* isolate, LanguageMode mode);
[ic] Introduce StoreOwnIC. ... which is used for initializing properties with non compile time values. Currently we use StoreOwnIC only for storing properties that already exist in the boilerplate therefore we can reuse StoreIC dispatcher. The proper StoreOwnIC dispatcher will be implemented in a separate CL. BUG=v8:5495, v8:4414 Change-Id: I9c33fdb8499ec5be2c7fce1ecb6ce7aa285e5844 Reviewed-on: https://chromium-review.googlesource.com/443588 Reviewed-by: Jakob Kummerow <jkummerow@chromium.org> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org> Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Commit-Queue: Igor Sheludko <ishell@chromium.org> Cr-Commit-Position: refs/heads/master@{#43285}
2017-02-17 15:15:07 +00:00
static Callable StoreOwnIC(Isolate* isolate);
static Callable StoreOwnICInOptimizedCode(Isolate* isolate);
Introduce LanguageMode, drop StrictMode. This enables adding more language modes in the future. For maximum flexibility, LanguageMode is a bitmask, so we're not restricted to use a sequence of language modes which are progressively stricter, but we can express the language mode as combination of features. For now, LanguageMode can only be "sloppy" or "strict", and there are STATIC_ASSERTS in places which need to change when more modes are added. LanguageMode is a bit like the old LanguageMode when "extended" mode was still around (see https://codereview.chromium.org/8417035 and https://codereview.chromium.org/181543002 ) except that it's transmitted through all the layers (there's no StrictModeFlag). BUG= Review URL: https://codereview.chromium.org/894683003 Cr-Commit-Position: refs/heads/master@{#26419}
2015-02-04 09:34:05 +00:00
static Callable KeyedStoreIC(Isolate* isolate, LanguageMode mode);
IC: Eliminate initialization_state as a factor in IC installation. In Crankshaft, we would install special ICs that didn't need a vector and slot in the MEGAMORPHIC case. This optimization limits our hand against future improvements. BUG= Review-Url: https://codereview.chromium.org/2019313003 Cr-Commit-Position: refs/heads/master@{#36597}
2016-05-30 19:26:02 +00:00
static Callable KeyedStoreICInOptimizedCode(Isolate* isolate,
LanguageMode mode);
[stubs] Port KeyedStoreIC dispatcher to TurboFan BUG= Review-Url: https://chromiumcodereview.appspot.com/2403483002 Cr-Commit-Position: refs/heads/master@{#40423}
2016-10-19 10:11:25 +00:00
static Callable KeyedStoreIC_Megamorphic(Isolate* isolate, LanguageMode mode);
Turbofan needs a code handle and a CallInterfaceDescriptor. At the same time we spread knowledge about how to create the initial IC code object too widely. Consolidate code creation and unify it with a descriptor via CodeFactory. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/567433002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23877 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-11 13:18:58 +00:00
[generators] Decouple generator resume from fullcodegen. Introduce a ResumeGeneratorTrampoline, which does the actual stack state reconstruction (currently always restores a fullcodegen frame), and introduce appropriate TurboFan builtins for %GeneratorPrototype%.next, %GeneratorPrototype%.return and %GeneratorPrototype%.throw based on this native builtin. Also unify the flooding in case of step-in to always work based on JSFunction and remove the special casing for JSGeneratorObject. R=mstarzinger@chromium.org, neis@chromium.org TBR=rossberg@chromium.org BUG=chromium:513471 LOG=n Review URL: https://codereview.chromium.org/1865833002 Cr-Commit-Position: refs/heads/master@{#35283}
2016-04-06 08:37:09 +00:00
static Callable ResumeGenerator(Isolate* isolate);
[liveedit] reimplement frame restarting. Previously, when restarting a frame, we would rewrite all frames between the debugger activation and the frame to restart to squash them, and replace the return address with that of a builtin to leave that rewritten frame, and restart the function by calling it. We now simply remember the frame to drop to, and upon returning from the debugger, we check whether to drop the frame, load the new FP, and restart the function. R=jgruber@chromium.org, mstarzinger@chromium.org BUG=v8:5587 Review-Url: https://codereview.chromium.org/2636913002 Cr-Commit-Position: refs/heads/master@{#42725}
2017-01-27 07:31:03 +00:00
static Callable FrameDropperTrampoline(Isolate* isolate);
static Callable HandleDebuggerStatement(Isolate* isolate);
Remove strong mode support from binary operations. R=bmeurer@chromium.org BUG=v8:3956 LOG=n Review URL: https://codereview.chromium.org/1693833002 Cr-Commit-Position: refs/heads/master@{#34036}
2016-02-16 13:54:51 +00:00
static Callable CompareIC(Isolate* isolate, Token::Value op);
[turbofan] Use CompareNilIC for abstract equality with null/undefined. Change CompareNilIC to return true/false instead of 1/0, and use the CompareNilICStub in TurboFan for abstract equality with null/undefined. This way we don't always run into the %Equals runtime fallback when comparing objects with null/undefined. R=jarin@chromium.org Review URL: https://codereview.chromium.org/1417503008 Cr-Commit-Position: refs/heads/master@{#31596}
2015-10-27 11:21:23 +00:00
static Callable CompareNilIC(Isolate* isolate, NilValue nil_value);
Turbofan needs a code handle and a CallInterfaceDescriptor. At the same time we spread knowledge about how to create the initial IC code object too widely. Consolidate code creation and unify it with a descriptor via CodeFactory. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/567433002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23877 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-11 13:18:58 +00:00
Remove strong mode support from binary operations. R=bmeurer@chromium.org BUG=v8:3956 LOG=n Review URL: https://codereview.chromium.org/1693833002 Cr-Commit-Position: refs/heads/master@{#34036}
2016-02-16 13:54:51 +00:00
static Callable BinaryOpIC(Isolate* isolate, Token::Value op);
Turbofan needs a code handle and a CallInterfaceDescriptor. At the same time we spread knowledge about how to create the initial IC code object too widely. Consolidate code creation and unify it with a descriptor via CodeFactory. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/567433002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23877 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-11 13:18:58 +00:00
Create per-descriptor-index LoadApiGetterStub This avoids custom compilation of receiver handlers for api getters. BUG= Review URL: https://codereview.chromium.org/1895093002 Cr-Commit-Position: refs/heads/master@{#35616}
2016-04-19 12:11:05 +00:00
static Callable ApiGetter(Isolate* isolate);
Turbofan needs a code handle and a CallInterfaceDescriptor. At the same time we spread knowledge about how to create the initial IC code object too widely. Consolidate code creation and unify it with a descriptor via CodeFactory. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/567433002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23877 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-11 13:18:58 +00:00
// Code stubs. Add methods here as needed to reduce dependency on
// code-stubs.h.
Correctify instanceof and make it optimizable. The previous hack with HInstanceOfKnownGlobal was not only slower, but also very brittle and required a lot of weird hacks to support it. And what's even more important it wasn't even correct (because a map check on the lhs is never enough for instanceof). The new implementation provides a sane runtime implementation for InstanceOf plus a fast case in the InstanceOfStub, combined with a proper specialization in the case of a known global in CrankShaft, which does only the prototype chain walk (coupled with a code dependency on the known global). As a drive-by-fix: Also fix the incorrect Object.prototype.isPrototypeOf implementation. BUG=v8:4376 LOG=y Review URL: https://codereview.chromium.org/1304633002 Cr-Commit-Position: refs/heads/master@{#30342}
2015-08-25 04:48:36 +00:00
static Callable InstanceOf(Isolate* isolate);
[turbofan] Properly optimize instanceof (even in the presence of @@hasInstance). This is the TurboFan counterpart of http://crrev.com/2504263004, but it is a bit more involved, since in TurboFan we always inline the appropriate call to the @@hasInstance handler, and by that we can optimize a lot more patterns of instanceof than Crankshaft, and even yield fast instanceof for custom @@hasInstance handlers (which we can now properly inline as well). Also we now properly optimize Function.prototype[@@hasInstance], even if the right hand side of an instanceof doesn't have the Function.prototype as its direct prototype. For the baseline case, we still rely on the global protector cell, but we can address that in a follow-up as well, and make it more robust in general. TEST=mjsunit/compiler/instanceof BUG=v8:5640 R=yangguo@chromium.org Review-Url: https://codereview.chromium.org/2511223003 Cr-Commit-Position: refs/heads/master@{#41092}
2016-11-18 06:30:57 +00:00
static Callable OrdinaryHasInstance(Isolate* isolate);
[turbofan] Add CodeFactory::Instanceof helper. R=mvstanton@chromium.org TEST=cctest/test-run-jsops/BinopInstanceOf Review URL: https://codereview.chromium.org/1196213004 Cr-Commit-Position: refs/heads/master@{#29187}
2015-06-22 12:15:55 +00:00
[turbofan]: Convert StringFromCharCode to var-args style TF builtin Review-Url: https://codereview.chromium.org/2448993002 Cr-Commit-Position: refs/heads/master@{#40814}
2016-11-07 21:26:18 +00:00
static Callable StringFromCharCode(Isolate* isolate);
[stubs] Introduce NonPrimitiveToPrimitive builtin. This adds initial support for ToPrimitive in JavaScript w/o having to call out to C++. This uses the newly introduced GetPropertyStub. R=ishell@chromium.org Review-Url: https://codereview.chromium.org/2152693002 Cr-Commit-Position: refs/heads/master@{#37753}
2016-07-14 10:25:45 +00:00
static Callable GetProperty(Isolate* isolate);
[turbofan] Desugar JSUnaryNot(x) to Select(x, false, true). Also remove the ResultMode from ToBooleanStub and always return true or false and use the same mechanism in fullcodegen. This is in preparation for adding ToBoolean hints to TurboFan. Drive-by-fix: We can use the power of the ToBooleanIC in TurboFan now that the ResultMode is gone (and the runtime always returns true or false from the miss handler). R=mstarzinger@chromium.org BUG=v8:4583 LOG=n Review URL: https://codereview.chromium.org/1491223002 Cr-Commit-Position: refs/heads/master@{#32524}
2015-12-02 15:21:47 +00:00
static Callable ToBoolean(Isolate* isolate);
Turbofan needs a code handle and a CallInterfaceDescriptor. At the same time we spread knowledge about how to create the initial IC code object too widely. Consolidate code creation and unify it with a descriptor via CodeFactory. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/567433002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23877 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-11 13:18:58 +00:00
static Callable ToNumber(Isolate* isolate);
[stubs] Split ToNumberStub into reusable subparts. Split ToNumberStub into the entry ToNumberStub, and two new stubs, StringToNumberStub and NonNumberToNumberStub, which can be used when we already know something about the input (i.e. in various branches of the code stubs, or in TurboFan graphs). Also introduce an appropriate StringToNumber simplified operator for TurboFan, that is pure and is lowered to an invocation of the newly added StringToNumberStub. R=jarin@chromium.org Review URL: https://codereview.chromium.org/1818923002 Cr-Commit-Position: refs/heads/master@{#34922}
2016-03-21 09:05:21 +00:00
static Callable NonNumberToNumber(Isolate* isolate);
static Callable StringToNumber(Isolate* isolate);
[runtime] Add %ToString and %_ToString and remove the TO_STRING builtin. This adds a new ToString runtime function and a fast-path ToStringStub (which is just a simple dispatcher for existing functionality), and also implements %_ToName using the ToStringStub. R=mstarzinger@chromium.org, yangguo@chromium.org BUG=v8:4307 LOG=n Review URL: https://codereview.chromium.org/1319973007 Cr-Commit-Position: refs/heads/master@{#30442}
2015-08-28 12:59:51 +00:00
static Callable ToString(Isolate* isolate);
[stubs] Introduce ToNameStub to implement %_ToName. We already had hand-written optimized code for %_ToName in fullcodegen, but the optimizing compilers always went to the runtime for %_ToName, which is pretty bad for many of our builtins. So this CL moves the existing native code to a ToNameStub (similar to the existing ToStringStub), and uses the ToNameStub consistently in all compilers to actually implement %_ToName. Review URL: https://codereview.chromium.org/1622493002 Cr-Commit-Position: refs/heads/master@{#33460}
2016-01-22 09:52:16 +00:00
static Callable ToName(Isolate* isolate);
[stubs] Introduce ToIntegerStub and unify the handling of %_ToInteger. This adds a new TurboFan-based ToIntegerStub, similar to the ToLengthStub, and uses it whereever we had custom code for %_ToInteger previously. R=yangguo@chromium.org BUG=v8:4587 LOG=n Review URL: https://codereview.chromium.org/1846683006 Cr-Commit-Position: refs/heads/master@{#35190}
2016-04-01 08:00:37 +00:00
static Callable ToInteger(Isolate* isolate);
[runtime] Implement %_ToLength via ToLengthStub. Use %_ToLength for TO_LENGTH, implemented via a ToLengthStub that supports a fast path for small integers. Everything else is still handled in the runtime. CQ_INCLUDE_TRYBOTS=tryserver.v8:v8_linux_nosnap_rel BUG=v8:4494 LOG=n Review URL: https://codereview.chromium.org/1412963002 Cr-Commit-Position: refs/heads/master@{#31358}
2015-10-19 08:35:00 +00:00
static Callable ToLength(Isolate* isolate);
[stubs] Unify (and optimize) implementation of ToObject. This is the initial (big) step towards a more uniform implementation of the ToObject abstract operation (ES6 7.1.13), where we have a fallback implementation in JSReceiver::ToObject() and a fast (hydrogen) CodeStub to deal with the fast case (we should be able to do more cleanup on this in a followup CL). For natives we expose the abstract operation via a %_ToObject intrinsic, also exposed via a macro TO_OBJECT, that unifies the previous confusion with TO_OBJECT_INLINE, ToObject, TO_OBJECT, $toObject and %$toObject. Now the whole implementation of the abstract operation is context independent, meaning we don't need any magic in the builtins object nor the native context. R=mvstanton@chromium.org,yangguo@chromium.org Review URL: https://codereview.chromium.org/1266013006 Cr-Commit-Position: refs/heads/master@{#29953}
2015-07-31 12:25:28 +00:00
static Callable ToObject(Isolate* isolate);
[stubs] Introduce NonPrimitiveToPrimitive builtin. This adds initial support for ToPrimitive in JavaScript w/o having to call out to C++. This uses the newly introduced GetPropertyStub. R=ishell@chromium.org Review-Url: https://codereview.chromium.org/2152693002 Cr-Commit-Position: refs/heads/master@{#37753}
2016-07-14 10:25:45 +00:00
static Callable NonPrimitiveToPrimitive(
Isolate* isolate, ToPrimitiveHint hint = ToPrimitiveHint::kDefault);
static Callable OrdinaryToPrimitive(Isolate* isolate,
OrdinaryToPrimitiveHint hint);
[fullcode] Make intrinsic-to-stub-call handling platform independent. Review URL: https://codereview.chromium.org/1412153002 Cr-Commit-Position: refs/heads/master@{#31372}
2015-10-19 11:59:24 +00:00
static Callable NumberToString(Isolate* isolate);
[turbofan] Some more cleanup on the intrinsics. Remove unused obsolete %_StringGetStringLength intrinsic, and properly optimize the %_SubString, %_RegExpExec, %_RegExpFlags, %_RegExpSource and %_RegExpConstructResult intrinsics. Review URL: https://codereview.chromium.org/1516753006 Cr-Commit-Position: refs/heads/master@{#32782}
2015-12-11 09:11:26 +00:00
static Callable RegExpExec(Isolate* isolate);
Turbofan needs a code handle and a CallInterfaceDescriptor. At the same time we spread knowledge about how to create the initial IC code object too widely. Consolidate code creation and unify it with a descriptor via CodeFactory. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/567433002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23877 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-11 13:18:58 +00:00
[stubs] Introduce AddStub and SubtractStub. This adds two new stubs, AddStub and SubtractStub, for the plus and the minus operators, and hooks them up with TurboFan and Ignition. Especially the addition case is very heavy and we might want to look into splitting that up further into specialized stubs (similar to what we did with ToNumberStub recently). R=epertoso@chromium.org Review URL: https://codereview.chromium.org/1823083002 Cr-Commit-Position: refs/heads/master@{#34994}
2016-03-22 15:42:24 +00:00
static Callable Add(Isolate* isolate);
static Callable Subtract(Isolate* isolate);
[stubs] Introduce MultiplyStub. Adds a MultiplyStub for the multiplication operator and hooks it with TurboFan and Ignition. Currently, the SMI times SMI case is handled by converting both the operands to double precision floating points, we may consider adding a fast path later. Review URL: https://codereview.chromium.org/1860043002 Cr-Commit-Position: refs/heads/master@{#35287}
2016-04-06 09:04:54 +00:00
static Callable Multiply(Isolate* isolate);
[stubs] Introduce DivideStub. Adds a DivideStub for the division operator and hooks it up with TurboFan and Ignition. Review URL: https://codereview.chromium.org/1865293003 Cr-Commit-Position: refs/heads/master@{#35364}
2016-04-08 14:53:04 +00:00
static Callable Divide(Isolate* isolate);
[stubs] Introduce ModulusStub. Adds a ModulusStub for the modulo operator and lets TurboFan and Ignition make use of it. Review URL: https://codereview.chromium.org/1876793002 Cr-Commit-Position: refs/heads/master@{#35389}
2016-04-11 13:54:14 +00:00
static Callable Modulus(Isolate* isolate);
[stubs] Introduce LeftShift, SignedRightShift and UnsignedRightShift stubs. Add the stubs for JavaScript's '<<', '>>' and '>>>' operators and lets Ignition make use of them in the respective bytecode handlers. Committed: https://crrev.com/599369d6b8e1a5ccdca857def06eebcbacf47dd4 Cr-Commit-Position: refs/heads/master@{#35433} Review URL: https://codereview.chromium.org/1881003002 Cr-Commit-Position: refs/heads/master@{#35446}
2016-04-13 13:51:23 +00:00
static Callable ShiftRight(Isolate* isolate);
static Callable ShiftRightLogical(Isolate* isolate);
static Callable ShiftLeft(Isolate* isolate);
[stubs] Introduce code stubs for bitwise binary operations. Add BitwiseAndStub, BitwiseOrStub and BitwiseXorStub, and hook them up with Ignition and TurboFan. R=epertoso@chromium.org Review URL: https://codereview.chromium.org/1825793002 Cr-Commit-Position: refs/heads/master@{#35029}
2016-03-23 13:44:32 +00:00
static Callable BitwiseAnd(Isolate* isolate);
static Callable BitwiseOr(Isolate* isolate);
static Callable BitwiseXor(Isolate* isolate);
[compiler] Initial TurboFan code stubs for abstract relational comparison. This adds new code stubs for abstract relational comparison, namely LessThanStub, LessThanOrEqualStub, GreaterThanStub and GreaterThanOrEqualStub, and hooks them up for Ignition and TurboFan. These stubs implement the full compare operation without any unpredictable bailouts. Currently they still go to C++ for string comparisons, and also use the %ToPrimitive_Number runtime entry, as we still lack a stub for the ToPrimitive operation. These issues will be addressed separately in follow-up CLs. Drive-by-fix: Add support for deferred code in the RawMachineAssembler and CodeStubAssembler. A block can be marked as deferred by marking its Label as deferred, which will then make the register allocator penalize this block and prefer better register assignments for the other blocks. R=epertoso@chromium.org Review URL: https://codereview.chromium.org/1759133002 Cr-Commit-Position: refs/heads/master@{#34463}
2016-03-03 16:38:55 +00:00
static Callable LessThan(Isolate* isolate);
static Callable LessThanOrEqual(Isolate* isolate);
static Callable GreaterThan(Isolate* isolate);
static Callable GreaterThanOrEqual(Isolate* isolate);
[compiler] Introduce code stubs for abstract equality. Add EqualStub and NotEqualStub, based on the CodeStubAssembler, and hook them up with TurboFan and Ignition. The stubs are a full implementation of abstract equality for ES6 plus the current SIMD.js draft, unlike the generic version of the CompareIC, which only implements a subset with funky runtime fallbacks. Drive-by-fix: Introduce some common helper methods. R=epertoso@chromium.org BUG=chromium:592690 LOG=n Review URL: https://codereview.chromium.org/1795793002 Cr-Commit-Position: refs/heads/master@{#34806}
2016-03-16 09:36:52 +00:00
static Callable Equal(Isolate* isolate);
[compiler] Introduce initial StrictEqualStub. Initial version of a new StrictEqualStub written as TurboFan code stub, that implements the full strict equality comparison and is usable for both TurboFan and Ignition (and soon for the generic CompareIC case too). The stub is not fully optimized yet, i.e. we still go to the runtime for string comparisons, but that'll be addressed in a follow-up CL. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/1753173003 Cr-Commit-Position: refs/heads/master@{#34423}
2016-03-02 11:46:57 +00:00
static Callable StrictEqual(Isolate* isolate);
Turbofan needs a code handle and a CallInterfaceDescriptor. At the same time we spread knowledge about how to create the initial IC code object too widely. Consolidate code creation and unify it with a descriptor via CodeFactory. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/567433002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23877 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-11 13:18:58 +00:00
static Callable StringAdd(Isolate* isolate, StringAddFlags flags,
PretenureFlag pretenure_flag);
[turbofan] Introduce a dedicated StringCharAt operator. Previously String element access and String.prototype.charAt were lowered to a subgraph StringFromCharCode(StringCharCodeAt(s, k)), however that can be fairly expensive both runtime and compile time wise. The dedicated StringCharAt operator is implemented via a call to a builtin that does exactly this. R=yangguo@chromium.org Review-Url: https://codereview.chromium.org/2599683002 Cr-Commit-Position: refs/heads/master@{#41909}
2016-12-22 06:49:07 +00:00
static Callable StringCharAt(Isolate* isolate);
[turbofan] Lower StringCharCodeAt to a dedicated builtin. Introduce a dedicated StringCharCodeAt builtin, that performs the core logic of String.prototype.charCodeAt and lower the StringCharCodeAt simplified operator to a call to this builtin rather than inlining the full functionality into each and every TurboFan graph using it. This can significantly reduce compile time in some cases (i.e. can easily shave off over 50% of compile time overhead for small functions that call String.prototype.charCodeAt). Currently it returns the char code as TaggedSigned value, but middle-term we should make it possible to return untagged values from builtins. R=yangguo@chromium.org Review-Url: https://codereview.chromium.org/2600443002 Cr-Commit-Position: refs/heads/master@{#41912}
2016-12-22 07:11:22 +00:00
static Callable StringCharCodeAt(Isolate* isolate);
[compiler] Introduce code stubs for string relational comparisons. Add StringLessThanStub, StringLessThanOrEqualStub, StringGreaterThanStub and StringGreaterThanOrEqualStub, based on the CodeStubAssembler, and hook them up with TurboFan (and Ignition). The stubs are currently essentially comparable with the StringCompareStub, which is now obsolete. We can later extend these stubs to cover more interesting cases (i.e. two byte sequential string comparisons, etc.). R=epertoso@chromium.org Review URL: https://codereview.chromium.org/1765823002 Cr-Commit-Position: refs/heads/master@{#34485}
2016-03-04 09:38:31 +00:00
static Callable StringCompare(Isolate* isolate, Token::Value token);
[compiler] Introduce StringEqualStub and StringNotEqualStub. These new stubs perform exactly the same job as the string equality case for the CompareIC, but are platform independent and usable outside of fullcodegen and Crankshaft. We use them in the StrictEqualStub and the StrictNotEqualStub instead of falling back to the runtime immediately for String comparisons, and we also use them in TurboFan to perform String equality or inequality comparisons. These stubs currently handle only internalized and one byte strings w/o going to C++, but it should be easy to add support for more string cases later, i.e. utilizing already flattened cons strings or comparing two byte strings as well. Review URL: https://codereview.chromium.org/1761823002 Cr-Commit-Position: refs/heads/master@{#34459}
2016-03-03 10:10:30 +00:00
static Callable StringEqual(Isolate* isolate);
[compiler] Introduce code stubs for string relational comparisons. Add StringLessThanStub, StringLessThanOrEqualStub, StringGreaterThanStub and StringGreaterThanOrEqualStub, based on the CodeStubAssembler, and hook them up with TurboFan (and Ignition). The stubs are currently essentially comparable with the StringCompareStub, which is now obsolete. We can later extend these stubs to cover more interesting cases (i.e. two byte sequential string comparisons, etc.). R=epertoso@chromium.org Review URL: https://codereview.chromium.org/1765823002 Cr-Commit-Position: refs/heads/master@{#34485}
2016-03-04 09:38:31 +00:00
static Callable StringLessThan(Isolate* isolate);
static Callable StringLessThanOrEqual(Isolate* isolate);
static Callable StringGreaterThan(Isolate* isolate);
static Callable StringGreaterThanOrEqual(Isolate* isolate);
[turbofan] Some more cleanup on the intrinsics. Remove unused obsolete %_StringGetStringLength intrinsic, and properly optimize the %_SubString, %_RegExpExec, %_RegExpFlags, %_RegExpSource and %_RegExpConstructResult intrinsics. Review URL: https://codereview.chromium.org/1516753006 Cr-Commit-Position: refs/heads/master@{#32782}
2015-12-11 09:11:26 +00:00
static Callable SubString(Isolate* isolate);
[builtins] Add String.prototype.indexOf fast path in TF Review-Url: https://codereview.chromium.org/2638393002 Cr-Commit-Position: refs/heads/master@{#42695}
2017-01-26 12:46:44 +00:00
static Callable StringIndexOf(Isolate* isolate);
Turbofan needs a code handle and a CallInterfaceDescriptor. At the same time we spread knowledge about how to create the initial IC code object too widely. Consolidate code creation and unify it with a descriptor via CodeFactory. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/567433002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23877 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-11 13:18:58 +00:00
[stubs] Add RegExpReplace and RegExpSplit stubs This adds helper stubs for RegExp split and replace operations, called directly by both RegExpPrototype{Replace,Split} and StringPrototype{Replace,Split}. BUG= Review-Url: https://codereview.chromium.org/2668703002 Cr-Commit-Position: refs/heads/master@{#42919}
2017-02-03 10:31:29 +00:00
static Callable RegExpReplace(Isolate* isolate);
static Callable RegExpSplit(Isolate* isolate);
[turbofan] Properly implement %_ClassOf intrinsic. The %_ClassOf intrinsic roughly corresponds to the deprecated ES5 [[Class]] internal property, and should not be used anymore ideally. However since we still have quite a couple of uses of this intrinsic in the self hosted JavaScript builtins, we would tank some builtins like Map, Set, WeakMap, WeakSet, etc. quite significantly unless we also support this intrinsic until the builtins are all migrated to C++/CSA builtins. R=yangguo@chromium.org BUG=v8:5267 Review-Url: https://codereview.chromium.org/2647833004 Cr-Commit-Position: refs/heads/master@{#42530}
2017-01-20 07:01:52 +00:00
static Callable ClassOf(Isolate* isolate);
Optimize the typeof operator. typeof was implemented as a runtime function. Calling it in optimized code with a non-constant input becomes burdensome. BUG= Review URL: https://codereview.chromium.org/1114563003 Cr-Commit-Position: refs/heads/master@{#28260}
2015-05-06 13:31:00 +00:00
static Callable Typeof(Isolate* isolate);
[es6] Perform the IsConstructor test in GetSuperConstructor. This is so that a NotSuperConstructor error is thrown before evaluating the arguments to the super constructor. Besides updating the runtime function, a new bytecode GetSuperConstructor is introduced. BUG=v8:5336 Review-Url: https://codereview.chromium.org/2504553003 Cr-Commit-Position: refs/heads/master@{#41788}
2016-12-19 10:12:22 +00:00
static Callable GetSuperConstructor(Isolate* isolate);
Optimize the typeof operator. typeof was implemented as a runtime function. Calling it in optimized code with a non-constant input becomes burdensome. BUG= Review URL: https://codereview.chromium.org/1114563003 Cr-Commit-Position: refs/heads/master@{#28260}
2015-05-06 13:31:00 +00:00
[runtime] First step to sanitize regexp literal creation. This is the initial step towards refactoring the regexp literation creation code to make it less obscure and more similar to the mechanism we use to create array and object literals. There's now a new runtime entry %CreateRegExpLiteral with the same interface as the entries for array and object literals, except that we still pass the flags as string. Instead of embedding the hand written native to clone JSRegExp instances we now have a FastCloneRegExpStub, which behaves similar to the other FastCloneShallowArrayStub and FastCloneShallowObjectStub that we already had. R=mlippautz@chromium.org, yangguo@chromium.org Review URL: https://codereview.chromium.org/1475823003 Cr-Commit-Position: refs/heads/master@{#32255}
2015-11-25 09:22:39 +00:00
static Callable FastCloneRegExp(Isolate* isolate);
[builtins] More stubs to the builtin-o-sphere. The following ported to builtins: FastCloneRegExp FastCloneShallowArray FastCloneShallowObject BUG= TBR=rmcilroy@chromium.org, rossberg@chromium.org Review-Url: https://codereview.chromium.org/2605893002 Cr-Commit-Position: refs/heads/master@{#41989}
2016-12-29 13:02:08 +00:00
static Callable FastCloneShallowArray(Isolate* isolate,
AllocationSiteMode allocation_mode);
[turbofan] Use FastCloneShallow[Array|Object]Stub if possible. This allows the JSIntrinsicLowering to optimize the cloning of literal boilerplate objects using either the FastCloneShallowArrayStub or the FastCloneShallowObjectStub when applicable. R=mvstanton@chromium.org Review URL: https://codereview.chromium.org/1097963002 Cr-Commit-Position: refs/heads/master@{#27974}
2015-04-21 15:43:31 +00:00
static Callable FastCloneShallowObject(Isolate* isolate, int length);
Use a different map to distinguish eval contexts eval() may introduce a scope which needs to be represented as a context at runtime, e.g., eval('var x; let y; ()=>y') introduces a variable y which needs to have a context allocated for it. However, when traversing upwards to find the declaration context for a variable which leaks, as the declaration of x does above, this context has to be understood to not be a declaration context in sloppy mode. This patch makes that distinction by introducing a different map for eval-introduced contexts. A dynamic search for the appropriate context will continue past an eval context to find the appropriate context. Marking contexts as eval contexts rather than function contexts required updates in each compiler backend. BUG=v8:5295, chromium:648719 Review-Url: https://codereview.chromium.org/2435023002 Cr-Commit-Position: refs/heads/master@{#41869}
2016-12-20 16:23:19 +00:00
static Callable FastNewFunctionContext(Isolate* isolate,
ScopeType scope_type);
[Code Stubs] Convert FastNewClosureStub to a TurboFanCodeStub. Converts FastNewClosureStub from a Hydrogen to a TurboFan code stub. The plan is to start using this in the Interpreter CreateClosure bytecode handler (in a follow-up CL). BUG=v8:4280 Review-Url: https://codereview.chromium.org/2100883003 Cr-Commit-Position: refs/heads/master@{#37429}
2016-06-30 09:42:29 +00:00
static Callable FastNewClosure(Isolate* isolate);
[stubs] Introduce a dedicated FastNewObjectStub. Move the already existing fast case for %NewObject into a dedicated FastNewObjectStub that we can utilize in places where we would otherwise fallback to %NewObject immediately, which is rather expensive. Also use FastNewObjectStub as the generic implementation of JSCreate, which should make constructor inlining based on SharedFunctionInfo (w/o specializing to a concrete closure) viable soon. R=jarin@chromium.org Review URL: https://codereview.chromium.org/1708313002 Cr-Commit-Position: refs/heads/master@{#34136}
2016-02-19 07:12:18 +00:00
static Callable FastNewObject(Isolate* isolate);
[builtins] Port parameter and argument-related code stubs to CSA Includes the port of these three builtins: FastNewStrictArguments, FastNewSloppyArguments and FastNewRestParameter. Also inline the implementation of these into the corresponding interpreter byte codes. BUG=v8:5269 LOG=N R=ishell@chromium.org, rmcilroy@chromium.org Review-Url: https://codereview.chromium.org/2645743002 Cr-Commit-Position: refs/heads/master@{#43002}
2017-02-07 16:02:44 +00:00
static Callable FastNewRestParameter(Isolate* isolate);
static Callable FastNewSloppyArguments(Isolate* isolate);
static Callable FastNewStrictArguments(Isolate* isolate);
[turbofan] Use FastNewClosureStub if possible. This introduces a JSCreateClosure operator which can be lowered by the typed pipeline to the aforementioned stub. It also allows for further optimizations of closure creation. R=titzer@chromium.org Review URL: https://codereview.chromium.org/1105513002 Cr-Commit-Position: refs/heads/master@{#28058}
2015-04-27 09:08:20 +00:00
[turbofan] Use fast stub for ForInPrepare and ForInNext Review-Url: https://codereview.chromium.org/2684043002 Cr-Commit-Position: refs/heads/master@{#43040}
2017-02-08 14:26:56 +00:00
static Callable ForInPrepare(Isolate* isolate);
static Callable ForInNext(Isolate* isolate);
[turbofan] Add initial support for growing stores. Introduce a dedicated MaybeGrowFastElements simplified operator, which tries to grow a fast elements backing store for a given element that should be added to an array/object. Use that to lower a growing keyed store to a sequence of 1) check index is a valid array index, 2) check stored value, 3) maybe grow elements backing store (and deoptimize if it would normalize), and 4) store the actual element. The actual growing is done by two dedicated GrowFastDoubleElements and GrowFastSmiOrObjectElements builtins, which are very similar to the GrowArrayElementsStub that is used by Crankshaft. Drive-by-fix: Turn CopyFixedArray into CopyFastSmiOrObjectElements builtin, similar to the new growing builtins, so we don't need to inline the store+write barrier for the elements into all optimized code objects anymore. Also fix a bug in the OperationTyper for NumberSilenceNaN, which was triggered by this change. BUG=v8:5272 Review-Url: https://codereview.chromium.org/2227493002 Cr-Commit-Position: refs/heads/master@{#38418}
2016-08-08 08:43:48 +00:00
static Callable CopyFastSmiOrObjectElements(Isolate* isolate);
static Callable GrowFastDoubleElements(Isolate* isolate);
static Callable GrowFastSmiOrObjectElements(Isolate* isolate);
[turbofan] Add support for copy-on-write element stores. This extends JSNativeContextSpecialization with support for stores to fast object/smi element backing stores that are marked as copy-on-write. In this case we first call the CopyFixedArray builtin to take a copy of the elements backing store, and then store the new elements back to the object, and finally perform the actual element store. R=epertoso@chromium.org BUG=v8:4470 Committed: https://crrev.com/ac98ad22f049a59c48387f1bab1590f135d219c6 Review-Url: https://codereview.chromium.org/2218703003 Cr-Original-Commit-Position: refs/heads/master@{#38370} Cr-Commit-Position: refs/heads/master@{#38392}
2016-08-05 15:28:52 +00:00
[turbofan] Add NewUnmappedArgumentsElements and NewRestParametersArguments. First step towards making arguments and rest parameters optimizable by splitting the allocations for the actual object and the elements. The object allocations can already be escape analyzed this way, the elements would need special support in the deoptimizer and the escape analysis, but that can be done as a second separate step. R=jarin@chromium.org BUG=v8:5726 Review-Url: https://codereview.chromium.org/2557283002 Cr-Commit-Position: refs/heads/master@{#41573}
2016-12-08 08:28:13 +00:00
static Callable NewUnmappedArgumentsElements(Isolate* isolate);
[turbofan] Add AllocateHeapNumberStub to avoid runtime call. TEST=unittests R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/703473004 Cr-Commit-Position: refs/heads/master@{#25107} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25107 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-11-04 12:58:17 +00:00
static Callable AllocateHeapNumber(Isolate* isolate);
[turbofan] Use the ArgumentsAdaptorTrampoline in case of argument count mismatch. Call directly into the ArgumentsAdaptorTrampoline when we call a known JSFunction, but that actual argument count doesn't match the expected argument count. R=jarin@chromium.org Review URL: https://codereview.chromium.org/1417213004 Cr-Commit-Position: refs/heads/master@{#31781}
2015-11-04 11:53:08 +00:00
static Callable ArgumentAdaptor(Isolate* isolate);
[builtins] Introduce specialized Call/CallFunction builtins. Introduce receiver conversion mode specialization for the Call and CallFunction builtins, so we can specialize the builtin functionality (actually an optimization only) based on static information from the callsite (this is basically a superset of the optimizations that were available with the CallFunctionStub and CallICStub, except that these optimizations are correct now). This fixes a regression introduced by the removal of CallFunctionStub, for programs that call a lot. R=yangguo@chromium.org BUG=chromium:552244 LOG=n Review URL: https://codereview.chromium.org/1436493002 Cr-Commit-Position: refs/heads/master@{#31871}
2015-11-09 08:47:59 +00:00
static Callable Call(Isolate* isolate,
[crankshaft] Support ES6 tail call elimination. HInvokeFunction and HApplyArguments instructions now support tail calling. Inlining of calls at tail position is not supported yet and therefore still disabled. The tail-call-megatest was modified so that the usages of "arguments" object do not disable Crankshaft. TBR=bmeurer@chromium.org BUG=v8:4698 LOG=N Review URL: https://codereview.chromium.org/1760253003 Cr-Commit-Position: refs/heads/master@{#34542}
2016-03-07 14:33:54 +00:00
ConvertReceiverMode mode = ConvertReceiverMode::kAny,
TailCallMode tail_call_mode = TailCallMode::kDisallow);
[Turbofan] Implement call with spread bytecode in assembly code. We can share almost all of the architecture-specific builtin code with super-call-with-spread. Info to port-writers: The code in CheckSpreadAndPushToStack has changed slightly from what was in Generate_ConstructWithSpread, in that we take the length of the spreaded parameters from the JSArray rather than the FixedArray backing store. BUG=v8:5511 Review-Url: https://codereview.chromium.org/2649143002 Cr-Commit-Position: refs/heads/master@{#42632}
2017-01-24 14:37:01 +00:00
static Callable CallWithSpread(Isolate* isolate);
[builtins] Introduce specialized Call/CallFunction builtins. Introduce receiver conversion mode specialization for the Call and CallFunction builtins, so we can specialize the builtin functionality (actually an optimization only) based on static information from the callsite (this is basically a superset of the optimizations that were available with the CallFunctionStub and CallICStub, except that these optimizations are correct now). This fixes a regression introduced by the removal of CallFunctionStub, for programs that call a lot. R=yangguo@chromium.org BUG=chromium:552244 LOG=n Review URL: https://codereview.chromium.org/1436493002 Cr-Commit-Position: refs/heads/master@{#31871}
2015-11-09 08:47:59 +00:00
static Callable CallFunction(
[stubs] Also port the CallICStub to CSA. Port the Call feedback machinery from the interpreter to the CallICStub as second step to unify the feedback collection. This removes a lot of hand-written native code, and makes the runtime miss handler obsolete. The next step will be to use the CallICStub from the interpreter as well. Drive-by-fix: Adjust CallIC/CallICTrampoline descriptors names. R=mvstanton@chromium.org BUG=v8:5049 Review-Url: https://codereview.chromium.org/2670843002 Cr-Commit-Position: refs/heads/master@{#42889}
2017-02-02 13:29:33 +00:00
Isolate* isolate, ConvertReceiverMode mode = ConvertReceiverMode::kAny,
TailCallMode tail_call_mode = TailCallMode::kDisallow);
[turbofan] Introduce JSCallForwardVarargs operator. We turn a JSCallFunction node for f.apply(receiver, arguments) into a JSCallForwardVarargs node, when the arguments refers to the arguments of the outermost optimized code object, i.e. not an inlined arguments, and the apply method refers to Function.prototype.apply, and there's no other user of arguments except in frame states. We also replace the arguments node in the graph with a marker for the Deoptimizer similar to Crankshaft to make sure we don't materialize unused arguments just for the sake of deoptimization. We plan to replace this with a saner EscapeAnalysis based solution soon. R=jarin@chromium.org BUG=v8:5267,v8:5726 Review-Url: https://codereview.chromium.org/2655233002 Cr-Commit-Position: refs/heads/master@{#42680}
2017-01-26 09:29:56 +00:00
static Callable CallForwardVarargs(Isolate* isolate);
static Callable CallFunctionForwardVarargs(Isolate* isolate);
[builtins] Sanitize the machinery around Construct calls. There's no point in collecting feedback for super constructor calls, because in all (interesting) cases we can gather (better) feedback from other sources (i.e. via inlining or via using a LOAD_IC to get to the [[Prototype]] of the target). So CallConstructStub is now only used for new Foo(...args) sites where we want to collect feedback in the baseline compiler. The optimizing compilers, Reflect.construct and super constructor calls use the Construct builtin directly, which allows us to remove some weird code from the CallConstructStub (and opens the possibility for more code sharing with the CallICStub, maybe even going for a ConstructICStub). Also remove the 100% redundant HCallNew instruction, which is just a wrapper for the Construct builtin anyway (indirectly via the CallConstructStub). Drive-by-fix: Drop unused has_function_cache bit on Code objects. R=mstarzinger@chromium.org, yangguo@chromium.org BUG=v8:4413, v8:4430 LOG=n Review URL: https://codereview.chromium.org/1469793002 Cr-Commit-Position: refs/heads/master@{#32172}
2015-11-23 10:34:04 +00:00
static Callable Construct(Isolate* isolate);
[Turbofan] Implement super calls with spread bytecode in assembly code. BUG=v8:5659 Review-Url: https://codereview.chromium.org/2571563004 Cr-Commit-Position: refs/heads/master@{#42444}
2017-01-18 10:34:24 +00:00
static Callable ConstructWithSpread(Isolate* isolate);
[turbofan] Optimize JSCallConstruct in typed lowering to direct calls. Lower JSCallConstruct with known target JSFunction to a direct call to the target's construct_stub, and JSCallConstruct with function target to direct call to ConstructFunction builtin. R=jarin@chromium.org Review URL: https://codereview.chromium.org/1517593003 Cr-Commit-Position: refs/heads/master@{#32735}
2015-12-10 06:03:37 +00:00
static Callable ConstructFunction(Isolate* isolate);
[stubs] Add CreateIterResultObject stub Most notably, the interpreter now calls this stub instead of the runtime. BUG= Review-Url: https://codereview.chromium.org/2619163004 Cr-Commit-Position: refs/heads/master@{#42218}
2017-01-11 11:34:02 +00:00
static Callable CreateIterResultObject(Isolate* isolate);
Add HasProperty code stub that tries simple lookups or jumps to runtime otherwise. Code common with ObjectHasOwnProperty builtin was moved to CodeStubAssembler. BUG=v8:2743 LOG=Y Review-Url: https://codereview.chromium.org/1894953004 Cr-Commit-Position: refs/heads/master@{#35972}
2016-05-03 11:11:27 +00:00
static Callable HasProperty(Isolate* isolate);
[fullcodegen] [crankshaft] Avoid jumping to the runtime for ForInFilter Use the ForInFilterStub directly. Hence we will only jump to the runtime for special receivers (instance_type <= LAST_SPECIAL_RECEIVER_TYPE) and for converting element indices which are not in the string cache. BUG= Review-Url: https://codereview.chromium.org/2151773002 Cr-Commit-Position: refs/heads/master@{#37934}
2016-07-21 09:33:26 +00:00
static Callable ForInFilter(Isolate* isolate);
[turbofan] Use the ArgumentsAdaptorTrampoline in case of argument count mismatch. Call directly into the ArgumentsAdaptorTrampoline when we call a known JSFunction, but that actual argument count doesn't match the expected argument count. R=jarin@chromium.org Review URL: https://codereview.chromium.org/1417213004 Cr-Commit-Position: refs/heads/master@{#31781}
2015-11-04 11:53:08 +00:00
[Turbofan] Implement call with spread bytecode in assembly code. We can share almost all of the architecture-specific builtin code with super-call-with-spread. Info to port-writers: The code in CheckSpreadAndPushToStack has changed slightly from what was in Generate_ConstructWithSpread, in that we take the length of the spreaded parameters from the JSArray rather than the FixedArray backing store. BUG=v8:5511 Review-Url: https://codereview.chromium.org/2649143002 Cr-Commit-Position: refs/heads/master@{#42632}
2017-01-24 14:37:01 +00:00
static Callable InterpreterPushArgsAndCall(Isolate* isolate,
TailCallMode tail_call_mode,
InterpreterPushArgsMode mode);
[Turbofan] Implement super calls with spread bytecode in assembly code. BUG=v8:5659 Review-Url: https://codereview.chromium.org/2571563004 Cr-Commit-Position: refs/heads/master@{#42444}
2017-01-18 10:34:24 +00:00
static Callable InterpreterPushArgsAndConstruct(Isolate* isolate,
[Turbofan] Implement call with spread bytecode in assembly code. We can share almost all of the architecture-specific builtin code with super-call-with-spread. Info to port-writers: The code in CheckSpreadAndPushToStack has changed slightly from what was in Generate_ConstructWithSpread, in that we take the length of the spreaded parameters from the JSArray rather than the FixedArray backing store. BUG=v8:5511 Review-Url: https://codereview.chromium.org/2649143002 Cr-Commit-Position: refs/heads/master@{#42632}
2017-01-24 14:37:01 +00:00
InterpreterPushArgsMode mode);
[Interpreter] Collect allocation site feedback in call bytecode handler. Adds support to collect allocation site feedback for Array function calls to the call bytecode handler. BUG=v8:4280, v8:4780 LOG=N Review-Url: https://codereview.chromium.org/2307903002 Cr-Commit-Position: refs/heads/master@{#39283}
2016-09-08 14:49:24 +00:00
static Callable InterpreterPushArgsAndConstructArray(Isolate* isolate);
[Interpreter] Add support for calling runtime functions which return a pair. Adds support for calling runtime functions which return a pair of values. Adds the bytecode CallRuntimePair. Also adds support to TurboFan for calling stubs which return multiple values. BUG=v8:4280 LOG=N Review URL: https://codereview.chromium.org/1568493002 Cr-Commit-Position: refs/heads/master@{#33181}
2016-01-08 15:15:52 +00:00
static Callable InterpreterCEntry(Isolate* isolate, int result_size = 1);
Reland of [interpreter] Add explicit OSR polling bytecode. (patchset #1 id:1 of https://codereview.chromium.org/2184553003/ ) Reason for revert: Fix has been landed. Original issue's description: > Revert of [interpreter] Add explicit OSR polling bytecode. (patchset #6 id:100001 of https://codereview.chromium.org/2172233002/ ) > > Reason for revert: > Bunch of breakages. Maybe bad interaction with https://chromium.googlesource.com/v8/v8/+/e520e5da5550f0d1a975e87d6e66a2edecbb0c8e ? > > E.g.: > https://build.chromium.org/p/client.v8/builders/V8%20Linux64/builds/11607 > > Original issue's description: > > [interpreter] Add explicit OSR polling bytecode. > > > > This adds an explicit {OsrPoll} bytecode into every loop header which > > triggers on-stack replacement when armed. Note that each such bytecode > > stores the static loop depths as an operand, and hence can be armed for > > specific loop depths. > > > > This also adds builtin code that triggers OSR compilation and switches > > execution over to optimized code in case compilation succeeds. In case > > compilation fails, the bytecode dispatch just continues unhindered. > > > > R=rmcilroy@chromium.org > > TEST=mjsunit/ignition/osr-from-bytecode > > BUG=v8:4764 > > > > Committed: https://crrev.com/a55beb68e0ededb3773affa294a71edc50621458 > > Cr-Commit-Position: refs/heads/master@{#38043} > > TBR=rmcilroy@chromium.org,mstarzinger@chromium.org > # Skipping CQ checks because original CL landed less than 1 days ago. > NOPRESUBMIT=true > NOTREECHECKS=true > NOTRY=true > BUG=v8:4764 > > Committed: https://crrev.com/439aa2c6d708bfd95db725bd6f97c4c49bbc51fc > Cr-Commit-Position: refs/heads/master@{#38044} TBR=rmcilroy@chromium.org,machenbach@chromium.org BUG=v8:4764 Review-Url: https://codereview.chromium.org/2184713002 Cr-Commit-Position: refs/heads/master@{#38056}
2016-07-26 14:31:10 +00:00
static Callable InterpreterOnStackReplacement(Isolate* isolate);
[stubs] Port builtin for Array.push fast-case from Crankshaft to TF Improves performance in simple, single element case by 5% and in multiple elements cases by 2%. BUG=chromium:608675 LOG=N Review-Url: https://codereview.chromium.org/2497243002 Cr-Commit-Position: refs/heads/master@{#41368}
2016-11-29 16:57:58 +00:00
[stubs] Also port the CallICStub to CSA. Port the Call feedback machinery from the interpreter to the CallICStub as second step to unify the feedback collection. This removes a lot of hand-written native code, and makes the runtime miss handler obsolete. The next step will be to use the CallICStub from the interpreter as well. Drive-by-fix: Adjust CallIC/CallICTrampoline descriptors names. R=mvstanton@chromium.org BUG=v8:5049 Review-Url: https://codereview.chromium.org/2670843002 Cr-Commit-Position: refs/heads/master@{#42889}
2017-02-02 13:29:33 +00:00
static Callable ArrayConstructor(Isolate* isolate);
[stubs] Port builtin for Array.push fast-case from Crankshaft to TF Improves performance in simple, single element case by 5% and in multiple elements cases by 2%. BUG=chromium:608675 LOG=N Review-Url: https://codereview.chromium.org/2497243002 Cr-Commit-Position: refs/heads/master@{#41368}
2016-11-29 16:57:58 +00:00
static Callable ArrayPush(Isolate* isolate);
[builtins] Separate Array.prototype.* CSA builtins into two parts Previous to this CL, CSA-optimized Array builtins--like forEach, some, and every--were written in a single, monolithic block of CSA code. This CL teases the code for each of these builtins apart into two chunks, a main body with optimizations for fast cases, and a "continuation" builtin that performs a spec-compliant, but slower version of the main loop of the builtin. The general idea is that when the "fast" main body builtin encounters an unexpected condition that invalidates assumptions allowing fast-case code, it tail calls to the slow, correct version of the loop that finishes the builtin execution. This separation currently doens't really provide any specific advantage over the combined version. However, it paves the way to TF-optimized inlined Array builtins. Inlined Array builtins may trigger deopts during the execution of the builtin's loop, and those deopt must continue execution from the point at which they failed. With some massaging of the deoptimizer, it will be possible to make those deopt points create an extra frame on the top of the stack which resumes execution in the slow-loop builtin created in this CL. BUG=v8:1956 LOG=N Review-Url: https://codereview.chromium.org/2753793002 Cr-Commit-Position: refs/heads/master@{#43867}
2017-03-16 15:34:01 +00:00
static Callable ArrayForEachLoopContinuation(Isolate* isolate);
static Callable ArraySomeLoopContinuation(Isolate* isolate);
static Callable ArrayEveryLoopContinuation(Isolate* isolate);
[stubs] Port FastFunctionBindStub to TF BUG=chromium:608675 LOG=N Review-Url: https://codereview.chromium.org/2532483002 Cr-Commit-Position: refs/heads/master@{#41439}
2016-12-01 21:15:08 +00:00
static Callable FunctionPrototypeBind(Isolate* isolate);
PromiseHandle port to TF Splits PromiseHandle into two TF builtins to account for catch prediction. An exception in PromiseHandleReject builtin results in a "caught" prediction whereas an expception in PromiseHandle results in a "promise rejection" prediction. An extra is_exception_caught bit is added to Code to mark this catch prediction behavior. BUG=v8:5343 Review-Url: https://codereview.chromium.org/2572623002 Cr-Commit-Position: refs/heads/master@{#41683}
2016-12-13 23:54:04 +00:00
static Callable PromiseHandleReject(Isolate* isolate);
Turbofan needs a code handle and a CallInterfaceDescriptor. At the same time we spread knowledge about how to create the initial IC code object too widely. Consolidate code creation and unify it with a descriptor via CodeFactory. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/567433002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23877 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-11 13:18:58 +00:00
};
[turbofan] Add AllocateHeapNumberStub to avoid runtime call. TEST=unittests R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/703473004 Cr-Commit-Position: refs/heads/master@{#25107} git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25107 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-11-04 12:58:17 +00:00
} // namespace internal
} // namespace v8
Turbofan needs a code handle and a CallInterfaceDescriptor. At the same time we spread knowledge about how to create the initial IC code object too widely. Consolidate code creation and unify it with a descriptor via CodeFactory. R=mstarzinger@chromium.org Review URL: https://codereview.chromium.org/567433002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23877 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-11 13:18:58 +00:00
#endif // V8_CODE_FACTORY_H_
Reference in New Issue Copy Permalink