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

182 lines
7.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"
#include "src/codegen.h"
#include "src/globals.h"
#include "src/interface-descriptors.h"
namespace v8 {
namespace internal {
// Associates a body of code with an interface descriptor.
Replace OVERRIDE->override and FINAL->final since we now require C++11. R=jochen@chromium.org Review URL: https://codereview.chromium.org/1088993003 Cr-Commit-Position: refs/heads/master@{#27937}
2015-04-20 13:08:11 +00:00
class Callable final BASE_EMBEDDED {
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:
Callable(Handle<Code> code, CallInterfaceDescriptor descriptor)
: code_(code), descriptor_(descriptor) {}
Handle<Code> code() const { return code_; }
CallInterfaceDescriptor descriptor() const { return descriptor_; }
private:
const Handle<Code> code_;
const CallInterfaceDescriptor descriptor_;
};
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:
// 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);
static Callable LoadICInOptimizedCode(Isolate* isolate);
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);
[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 CallICInOptimizedCode(
[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);
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);
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);
[Interpreter] Introduce IncStub and DecStub. Adds IncStub and DecStub TurboFan code stubs and hooks them up to the interpreter's Inc and Dec bytecodes (which are used for count operations, e.g. i++). BUG=v8:4280 LOG=N Review URL: https://codereview.chromium.org/1901083002 Cr-Commit-Position: refs/heads/master@{#35720}
2016-04-22 10:35:42 +00:00
static Callable Inc(Isolate* isolate);
static Callable Dec(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);
static Callable NotEqual(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);
[compiler] Introduce proper StrictNotEqualStub. Generalize the code that we have for StrictEqualStub to also general a StrictNotEqualStub and hook that up with TurboFan and Ignition. It's still falling back to the runtime for every String (in)equality check. R=yangguo@chromium.org Review URL: https://codereview.chromium.org/1756793002 Cr-Commit-Position: refs/heads/master@{#34426}
2016-03-02 12:34:36 +00:00
static Callable StrictNotEqual(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
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);
[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);
static Callable StringNotEqual(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);
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
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);
[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);
[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 FastCloneShallowArray(Isolate* isolate);
static Callable FastCloneShallowObject(Isolate* isolate, int length);
Make FastNewFunctionContextStub take slots parameter This will enable the interpreter to add a bytecode and use the stub. BUG=v8:4280 LOG=n Review-Url: https://codereview.chromium.org/2177273002 Cr-Commit-Position: refs/heads/master@{#38219}
2016-08-01 19:26:46 +00:00
static Callable FastNewFunctionContext(Isolate* isolate);
[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);
[Interpreter] Fix incorrect frame walking in arguments create stubs The previous approach taken by FastNew[Sloppy,Strict,Rest]ArgumentsStub looked at the function slot in order to skip stub frames and find the JS frame. However, stub frames do not have a function slot (in fact their fixed frame ends one slot before the JS frame's function slot). Therefore, if this location in the stub frame happens to have the function object the create arguments stubs won't skip this frame correctly. Replace this approach with one where the stub is specialized to either skip a frame if required (since there will only ever be one extra frame on Ignition the loop approach isn't necessary). BUG=v8:4928 LOG=N CQ_INCLUDE_TRYBOTS=tryserver.v8:v8_linux_nosnap_dbg Review-Url: https://codereview.chromium.org/1949023003 Cr-Commit-Position: refs/heads/master@{#36181}
2016-05-11 15:06:40 +00:00
static Callable FastNewRestParameter(Isolate* isolate,
bool skip_stub_frame = false);
static Callable FastNewSloppyArguments(Isolate* isolate,
bool skip_stub_frame = false);
static Callable FastNewStrictArguments(Isolate* isolate,
bool skip_stub_frame = false);
[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] 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);
static Callable NewRestParameterElements(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);
Add Simd128Value code stubs. LOG=N BUG=v8:4124 Review URL: https://codereview.chromium.org/1706053002 Cr-Commit-Position: refs/heads/master@{#34951}
2016-03-21 15:45:32 +00:00
#define SIMD128_ALLOC(TYPE, Type, type, lane_count, lane_type) \
static Callable Allocate##Type(Isolate* isolate);
SIMD128_TYPES(SIMD128_ALLOC)
#undef SIMD128_ALLOC
[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
[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);
[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(
Isolate* isolate, ConvertReceiverMode mode = ConvertReceiverMode::kAny);
[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] 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);
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
[Interpreter] Collect type feedback for calls in the bytecode handler Collect type feedback in the call bytecode handler. The current implementation only collects feedback for JS function objects. The other objects and Array functions do not collect any feedback. They will be marked Megamorphic. BUG=v8:4280, v8:4780 LOG=N Review-Url: https://codereview.chromium.org/2122183002 Cr-Commit-Position: refs/heads/master@{#37700}
2016-07-13 07:58:40 +00:00
static Callable InterpreterPushArgsAndCall(
Isolate* isolate, TailCallMode tail_call_mode,
CallableType function_type = CallableType::kAny);
[Interpreter] Collect type feedback for 'new' in the bytecode handler Collect type feedback in the bytecode handler for 'new' bytecode. The earlier cl (https://codereview.chromium.org/2153433002/) was reverted because that implementation did not collect allocation site feedback. This regressed delta blue by an order of magnitude. This implementation includes collection of allocation site feedback. Reland of https://codereview.chromium.org/2190293003/ with a bug fix. BUG=v8:4280, v8:4780 LOG=N Review-Url: https://codereview.chromium.org/2225923003 Cr-Commit-Position: refs/heads/master@{#39120}
2016-09-02 08:26:36 +00:00
static Callable InterpreterPushArgsAndConstruct(
Isolate* isolate, CallableType function_type = CallableType::kAny);
[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
static Callable ArrayPush(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