author | hannesw |
Thu, 21 Sep 2017 14:40:50 +0200 | |
changeset 47232 | 205e4c0dc8a3 |
parent 47216 | 71c04702a3d5 |
permissions | -rw-r--r-- |
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
1 |
/* |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
2 |
* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved. |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
4 |
* |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
5 |
* This code is free software; you can redistribute it and/or modify it |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
7 |
* published by the Free Software Foundation. Oracle designates this |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
8 |
* particular file as subject to the "Classpath" exception as provided |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
9 |
* by Oracle in the LICENSE file that accompanied this code. |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
10 |
* |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
11 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
12 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
13 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
14 |
* version 2 for more details (a copy is included in the LICENSE file that |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
15 |
* accompanied this code). |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
16 |
* |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
17 |
* You should have received a copy of the GNU General Public License version |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
18 |
* 2 along with this work; if not, write to the Free Software Foundation, |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
19 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
20 |
* |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
21 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
22 |
* or visit www.oracle.com if you need additional information or have any |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
23 |
* questions. |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
24 |
*/ |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
25 |
package jdk.nashorn.internal.runtime; |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
26 |
|
24719 | 27 |
import static jdk.nashorn.internal.lookup.Lookup.MH; |
28 |
import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.INVALID_PROGRAM_POINT; |
|
29 |
import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.isValid; |
|
32435
cfd619ef23a6
8133300: Ensure symbol table immutability in Nashorn AST
attila
parents:
31548
diff
changeset
|
30 |
|
24719 | 31 |
import java.lang.invoke.CallSite; |
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
32 |
import java.lang.invoke.MethodHandle; |
24719 | 33 |
import java.lang.invoke.MethodHandles; |
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
34 |
import java.lang.invoke.MethodType; |
24719 | 35 |
import java.lang.invoke.MutableCallSite; |
36 |
import java.lang.invoke.SwitchPoint; |
|
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
37 |
import java.util.ArrayList; |
26768
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
38 |
import java.util.Collection; |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
39 |
import java.util.Collections; |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
40 |
import java.util.Iterator; |
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
41 |
import java.util.List; |
24719 | 42 |
import java.util.Map; |
43 |
import java.util.TreeMap; |
|
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
44 |
import java.util.function.Supplier; |
24731
ab0c8fc915ae
8038406: Testability: as a first step of moving loggers away from the process global space, the Debug object now supports logging POJOs from log entries as an event queue, which can be introspected from test scripts. This is way better than screen scraping brittle and subject-to-change log output.
lagergren
parents:
24729
diff
changeset
|
45 |
import java.util.logging.Level; |
34447
ec4c069f9436
8141338: Move jdk.internal.dynalink package to jdk.dynalink
attila
parents:
32534
diff
changeset
|
46 |
import jdk.dynalink.linker.GuardedInvocation; |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
47 |
import jdk.nashorn.internal.codegen.Compiler; |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
48 |
import jdk.nashorn.internal.codegen.Compiler.CompilationPhases; |
26055
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
49 |
import jdk.nashorn.internal.codegen.TypeMap; |
24719 | 50 |
import jdk.nashorn.internal.codegen.types.ArrayType; |
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
51 |
import jdk.nashorn.internal.codegen.types.Type; |
24719 | 52 |
import jdk.nashorn.internal.ir.FunctionNode; |
26768
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
53 |
import jdk.nashorn.internal.objects.annotations.SpecializedFunction.LinkLogic; |
24742
a9afb384e654
8040655: When processing a RewriteException debug object, the return value has already been reset to null. We need to catch this value before that.
lagergren
parents:
24741
diff
changeset
|
54 |
import jdk.nashorn.internal.runtime.events.RecompilationEvent; |
24719 | 55 |
import jdk.nashorn.internal.runtime.linker.Bootstrap; |
24744
5290da85fc3d
8038426: Move all loggers from process wide scope into Global scope
lagergren
parents:
24742
diff
changeset
|
56 |
import jdk.nashorn.internal.runtime.logging.DebugLogger; |
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
57 |
|
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
58 |
/** |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
59 |
* An version of a JavaScript function, native or JavaScript. |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
60 |
* Supports lazily generating a constructor version of the invocation. |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
61 |
*/ |
24719 | 62 |
final class CompiledFunction { |
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
63 |
|
24719 | 64 |
private static final MethodHandle NEWFILTER = findOwnMH("newFilter", Object.class, Object.class, Object.class); |
65 |
private static final MethodHandle RELINK_COMPOSABLE_INVOKER = findOwnMH("relinkComposableInvoker", void.class, CallSite.class, CompiledFunction.class, boolean.class); |
|
66 |
private static final MethodHandle HANDLE_REWRITE_EXCEPTION = findOwnMH("handleRewriteException", MethodHandle.class, CompiledFunction.class, OptimismInfo.class, RewriteException.class); |
|
67 |
private static final MethodHandle RESTOF_INVOKER = MethodHandles.exactInvoker(MethodType.methodType(Object.class, RewriteException.class)); |
|
68 |
||
24744
5290da85fc3d
8038426: Move all loggers from process wide scope into Global scope
lagergren
parents:
24742
diff
changeset
|
69 |
private final DebugLogger log; |
24719 | 70 |
|
26768
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
71 |
static final Collection<CompiledFunction> NO_FUNCTIONS = Collections.emptySet(); |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
72 |
|
24719 | 73 |
/** |
74 |
* The method type may be more specific than the invoker, if. e.g. |
|
75 |
* the invoker is guarded, and a guard with a generic object only |
|
76 |
* fallback, while the target is more specific, we still need the |
|
77 |
* more specific type for sorting |
|
78 |
*/ |
|
79 |
private MethodHandle invoker; |
|
80 |
private MethodHandle constructor; |
|
81 |
private OptimismInfo optimismInfo; |
|
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
82 |
private final int flags; // from FunctionNode |
26055
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
83 |
private final MethodType callSiteType; |
24719 | 84 |
|
26768
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
85 |
private final Specialization specialization; |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
86 |
|
24719 | 87 |
CompiledFunction(final MethodHandle invoker) { |
26768
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
88 |
this(invoker, null, null); |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
89 |
} |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
90 |
|
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
91 |
static CompiledFunction createBuiltInConstructor(final MethodHandle invoker, final Specialization specialization) { |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
92 |
return new CompiledFunction(MH.insertArguments(invoker, 0, false), createConstructorFromInvoker(MH.insertArguments(invoker, 0, true)), specialization); |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
93 |
} |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
94 |
|
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
95 |
CompiledFunction(final MethodHandle invoker, final MethodHandle constructor, final Specialization specialization) { |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
96 |
this(invoker, constructor, 0, null, specialization, DebugLogger.DISABLED_LOGGER); |
24719 | 97 |
} |
98 |
||
26768
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
99 |
CompiledFunction(final MethodHandle invoker, final MethodHandle constructor, final int flags, final MethodType callSiteType, final Specialization specialization, final DebugLogger log) { |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
100 |
this.specialization = specialization; |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
101 |
if (specialization != null && specialization.isOptimistic()) { |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
102 |
/* |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
103 |
* An optimistic builtin with isOptimistic=true works like any optimistic generated function, i.e. it |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
104 |
* can throw unwarranted optimism exceptions. As native functions trivially can't have parts of them |
32534
b3ec7f3b3c2a
8136349: Typos patch for nashorn sources submitted on Sep 10, 2015
sundar
parents:
32435
diff
changeset
|
105 |
* regenerated as "restOf" methods, this only works if the methods are atomic/functional in their behavior |
26768
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
106 |
* and doesn't modify state before an UOE can be thrown. If they aren't, we can reexecute a wider version |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
107 |
* of the same builtin in a recompilation handler for FinalScriptFunctionData. There are several |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
108 |
* candidate methods in Native* that would benefit from this, but I haven't had time to implement any |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
109 |
* of them currently. In order to fit in with the relinking framework, the current thinking is |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
110 |
* that the methods still take a program point to fit in with other optimistic functions, but |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
111 |
* it is set to "first", which is the beginning of the method. The relinker can tell the difference |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
112 |
* between builtin and JavaScript functions. This might change. TODO |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
113 |
*/ |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
114 |
this.invoker = MH.insertArguments(invoker, invoker.type().parameterCount() - 1, UnwarrantedOptimismException.FIRST_PROGRAM_POINT); |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
115 |
throw new AssertionError("Optimistic (UnwarrantedOptimismException throwing) builtin functions are currently not in use"); |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
116 |
} |
26886
18c744ab4df2
8059211: Changed ArrayData.length accessor to use the protected field and fixed javadoc warnings related to this
lagergren
parents:
26768
diff
changeset
|
117 |
this.invoker = invoker; |
17756
daaa1e643f71
8006069: Range analysis first iteration, runtime specializations
lagergren
parents:
17518
diff
changeset
|
118 |
this.constructor = constructor; |
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
119 |
this.flags = flags; |
26055
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
120 |
this.callSiteType = callSiteType; |
24745
3a6e1477362b
8041434: Add synchronization to the common global constants structure
lagergren
parents:
24744
diff
changeset
|
121 |
this.log = log; |
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
122 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
123 |
|
25236
fac419f1e889
8046921: Deoptimization type information peristence
attila
parents:
24779
diff
changeset
|
124 |
CompiledFunction(final MethodHandle invoker, final RecompilableScriptFunctionData functionData, |
26055
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
125 |
final Map<Integer, Type> invalidatedProgramPoints, final MethodType callSiteType, final int flags) { |
26768
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
126 |
this(invoker, null, flags, callSiteType, null, functionData.getLogger()); |
24751 | 127 |
if ((flags & FunctionNode.IS_DEOPTIMIZABLE) != 0) { |
25236
fac419f1e889
8046921: Deoptimization type information peristence
attila
parents:
24779
diff
changeset
|
128 |
optimismInfo = new OptimismInfo(functionData, invalidatedProgramPoints); |
24719 | 129 |
} else { |
130 |
optimismInfo = null; |
|
131 |
} |
|
132 |
} |
|
133 |
||
26768
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
134 |
static CompiledFunction createBuiltInConstructor(final MethodHandle invoker) { |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
135 |
return new CompiledFunction(MH.insertArguments(invoker, 0, false), createConstructorFromInvoker(MH.insertArguments(invoker, 0, true)), null); |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
136 |
} |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
137 |
|
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
138 |
boolean isSpecialization() { |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
139 |
return specialization != null; |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
140 |
} |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
141 |
|
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
142 |
boolean hasLinkLogic() { |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
143 |
return getLinkLogicClass() != null; |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
144 |
} |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
145 |
|
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
146 |
Class<? extends LinkLogic> getLinkLogicClass() { |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
147 |
if (isSpecialization()) { |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
148 |
final Class<? extends LinkLogic> linkLogicClass = specialization.getLinkLogicClass(); |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
149 |
assert !LinkLogic.isEmpty(linkLogicClass) : "empty link logic classes should have been removed by nasgen"; |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
150 |
return linkLogicClass; |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
151 |
} |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
152 |
return null; |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
153 |
} |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
154 |
|
42376
8604f1a50c30
8170322: Specialized functions convert booleans to numbers
hannesw
parents:
34447
diff
changeset
|
155 |
boolean convertsNumericArgs() { |
8604f1a50c30
8170322: Specialized functions convert booleans to numbers
hannesw
parents:
34447
diff
changeset
|
156 |
return isSpecialization() && specialization.convertsNumericArgs(); |
8604f1a50c30
8170322: Specialized functions convert booleans to numbers
hannesw
parents:
34447
diff
changeset
|
157 |
} |
8604f1a50c30
8170322: Specialized functions convert booleans to numbers
hannesw
parents:
34447
diff
changeset
|
158 |
|
24738
be2026c9717c
8039746: Transform applies to calls wherever possible, for ScriptFunctions and JSObjects.
lagergren
parents:
24731
diff
changeset
|
159 |
int getFlags() { |
be2026c9717c
8039746: Transform applies to calls wherever possible, for ScriptFunctions and JSObjects.
lagergren
parents:
24731
diff
changeset
|
160 |
return flags; |
be2026c9717c
8039746: Transform applies to calls wherever possible, for ScriptFunctions and JSObjects.
lagergren
parents:
24731
diff
changeset
|
161 |
} |
be2026c9717c
8039746: Transform applies to calls wherever possible, for ScriptFunctions and JSObjects.
lagergren
parents:
24731
diff
changeset
|
162 |
|
26768
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
163 |
/** |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
164 |
* An optimistic specialization is one that can throw UnwarrantedOptimismException. |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
165 |
* This is allowed for native methods, as long as they are functional, i.e. don't change |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
166 |
* any state between entering and throwing the UOE. Then we can re-execute a wider version |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
167 |
* of the method in the continuation. Rest-of method generation for optimistic builtins is |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
168 |
* of course not possible, but this approach works and fits into the same relinking |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
169 |
* framework |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
170 |
* |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
171 |
* @return true if optimistic builtin |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
172 |
*/ |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
173 |
boolean isOptimistic() { |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
174 |
return isSpecialization() ? specialization.isOptimistic() : false; |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
175 |
} |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
176 |
|
24740
26791be09688
8040089: Apply to call transform was incomplete. Now passes all tests and performance is back
lagergren
parents:
24738
diff
changeset
|
177 |
boolean isApplyToCall() { |
24751 | 178 |
return (flags & FunctionNode.HAS_APPLY_TO_CALL_SPECIALIZATION) != 0; |
24740
26791be09688
8040089: Apply to call transform was incomplete. Now passes all tests and performance is back
lagergren
parents:
24738
diff
changeset
|
179 |
} |
26791be09688
8040089: Apply to call transform was incomplete. Now passes all tests and performance is back
lagergren
parents:
24738
diff
changeset
|
180 |
|
24738
be2026c9717c
8039746: Transform applies to calls wherever possible, for ScriptFunctions and JSObjects.
lagergren
parents:
24731
diff
changeset
|
181 |
boolean isVarArg() { |
be2026c9717c
8039746: Transform applies to calls wherever possible, for ScriptFunctions and JSObjects.
lagergren
parents:
24731
diff
changeset
|
182 |
return isVarArgsType(invoker.type()); |
be2026c9717c
8039746: Transform applies to calls wherever possible, for ScriptFunctions and JSObjects.
lagergren
parents:
24731
diff
changeset
|
183 |
} |
be2026c9717c
8039746: Transform applies to calls wherever possible, for ScriptFunctions and JSObjects.
lagergren
parents:
24731
diff
changeset
|
184 |
|
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
185 |
@Override |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
186 |
public String toString() { |
26768
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
187 |
final StringBuilder sb = new StringBuilder(); |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
188 |
final Class<? extends LinkLogic> linkLogicClass = getLinkLogicClass(); |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
189 |
|
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
190 |
sb.append("[invokerType="). |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
191 |
append(invoker.type()). |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
192 |
append(" ctor="). |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
193 |
append(constructor). |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
194 |
append(" weight="). |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
195 |
append(weight()). |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
196 |
append(" linkLogic="). |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
197 |
append(linkLogicClass != null ? linkLogicClass.getSimpleName() : "none"); |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
198 |
|
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
199 |
return sb.toString(); |
24719 | 200 |
} |
201 |
||
202 |
boolean needsCallee() { |
|
203 |
return ScriptFunctionData.needsCallee(invoker); |
|
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
204 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
205 |
|
24719 | 206 |
/** |
207 |
* Returns an invoker method handle for this function. Note that the handle is safely composable in |
|
208 |
* the sense that you can compose it with other handles using any combinators even if you can't affect call site |
|
209 |
* invalidation. If this compiled function is non-optimistic, then it returns the same value as |
|
26055
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
210 |
* {@link #getInvokerOrConstructor(boolean)}. However, if the function is optimistic, then this handle will |
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
211 |
* incur an overhead as it will add an intermediate internal call site that can relink itself when the function |
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
212 |
* needs to regenerate its code to always point at the latest generated code version. |
24719 | 213 |
* @return a guaranteed composable invoker method handle for this function. |
214 |
*/ |
|
215 |
MethodHandle createComposableInvoker() { |
|
216 |
return createComposableInvoker(false); |
|
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
217 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
218 |
|
24719 | 219 |
/** |
220 |
* Returns an invoker method handle for this function when invoked as a constructor. Note that the handle should be |
|
221 |
* considered non-composable in the sense that you can only compose it with other handles using any combinators if |
|
222 |
* you can ensure that the composition is guarded by {@link #getOptimisticAssumptionsSwitchPoint()} if it's |
|
223 |
* non-null, and that you can relink the call site it is set into as a target if the switch point is invalidated. In |
|
224 |
* all other cases, use {@link #createComposableConstructor()}. |
|
225 |
* @return a direct constructor method handle for this function. |
|
226 |
*/ |
|
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
227 |
private MethodHandle getConstructor() { |
24738
be2026c9717c
8039746: Transform applies to calls wherever possible, for ScriptFunctions and JSObjects.
lagergren
parents:
24731
diff
changeset
|
228 |
if (constructor == null) { |
24719 | 229 |
constructor = createConstructorFromInvoker(createInvokerForPessimisticCaller()); |
230 |
} |
|
231 |
||
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
232 |
return constructor; |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
233 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
234 |
|
24719 | 235 |
/** |
236 |
* Creates a version of the invoker intended for a pessimistic caller (return type is Object, no caller optimistic |
|
237 |
* program point available). |
|
238 |
* @return a version of the invoker intended for a pessimistic caller. |
|
239 |
*/ |
|
240 |
private MethodHandle createInvokerForPessimisticCaller() { |
|
241 |
return createInvoker(Object.class, INVALID_PROGRAM_POINT); |
|
242 |
} |
|
243 |
||
244 |
/** |
|
245 |
* Compose a constructor from an invoker. |
|
246 |
* |
|
247 |
* @param invoker invoker |
|
248 |
* @return the composed constructor |
|
249 |
*/ |
|
250 |
private static MethodHandle createConstructorFromInvoker(final MethodHandle invoker) { |
|
251 |
final boolean needsCallee = ScriptFunctionData.needsCallee(invoker); |
|
252 |
// If it was (callee, this, args...), permute it to (this, callee, args...). We're doing this because having |
|
253 |
// "this" in the first argument position is what allows the elegant folded composition of |
|
254 |
// (newFilter x constructor x allocator) further down below in the code. Also, ensure the composite constructor |
|
255 |
// always returns Object. |
|
256 |
final MethodHandle swapped = needsCallee ? swapCalleeAndThis(invoker) : invoker; |
|
257 |
||
258 |
final MethodHandle returnsObject = MH.asType(swapped, swapped.type().changeReturnType(Object.class)); |
|
259 |
||
260 |
final MethodType ctorType = returnsObject.type(); |
|
261 |
||
262 |
// Construct a dropping type list for NEWFILTER, but don't include constructor "this" into it, so it's actually |
|
263 |
// captured as "allocation" parameter of NEWFILTER after we fold the constructor into it. |
|
264 |
// (this, [callee, ]args...) => ([callee, ]args...) |
|
265 |
final Class<?>[] ctorArgs = ctorType.dropParameterTypes(0, 1).parameterArray(); |
|
266 |
||
267 |
// Fold constructor into newFilter that replaces the return value from the constructor with the originally |
|
268 |
// allocated value when the originally allocated value is a JS primitive (String, Boolean, Number). |
|
269 |
// (result, this, [callee, ]args...) x (this, [callee, ]args...) => (this, [callee, ]args...) |
|
270 |
final MethodHandle filtered = MH.foldArguments(MH.dropArguments(NEWFILTER, 2, ctorArgs), returnsObject); |
|
271 |
||
272 |
// allocate() takes a ScriptFunction and returns a newly allocated ScriptObject... |
|
273 |
if (needsCallee) { |
|
274 |
// ...we either fold it into the previous composition, if we need both the ScriptFunction callee object and |
|
275 |
// the newly allocated object in the arguments, so (this, callee, args...) x (callee) => (callee, args...), |
|
276 |
// or... |
|
277 |
return MH.foldArguments(filtered, ScriptFunction.ALLOCATE); |
|
278 |
} |
|
279 |
||
280 |
// ...replace the ScriptFunction argument with the newly allocated object, if it doesn't need the callee |
|
281 |
// (this, args...) filter (callee) => (callee, args...) |
|
282 |
return MH.filterArguments(filtered, 0, ScriptFunction.ALLOCATE); |
|
283 |
} |
|
284 |
||
285 |
/** |
|
286 |
* Permutes the parameters in the method handle from {@code (callee, this, ...)} to {@code (this, callee, ...)}. |
|
287 |
* Used when creating a constructor handle. |
|
288 |
* @param mh a method handle with order of arguments {@code (callee, this, ...)} |
|
289 |
* @return a method handle with order of arguments {@code (this, callee, ...)} |
|
290 |
*/ |
|
291 |
private static MethodHandle swapCalleeAndThis(final MethodHandle mh) { |
|
292 |
final MethodType type = mh.type(); |
|
293 |
assert type.parameterType(0) == ScriptFunction.class : type; |
|
294 |
assert type.parameterType(1) == Object.class : type; |
|
295 |
final MethodType newType = type.changeParameterType(0, Object.class).changeParameterType(1, ScriptFunction.class); |
|
296 |
final int[] reorder = new int[type.parameterCount()]; |
|
297 |
reorder[0] = 1; |
|
298 |
assert reorder[1] == 0; |
|
299 |
for (int i = 2; i < reorder.length; ++i) { |
|
300 |
reorder[i] = i; |
|
301 |
} |
|
302 |
return MethodHandles.permuteArguments(mh, newType, reorder); |
|
303 |
} |
|
304 |
||
305 |
/** |
|
306 |
* Returns an invoker method handle for this function when invoked as a constructor. Note that the handle is safely |
|
307 |
* composable in the sense that you can compose it with other handles using any combinators even if you can't affect |
|
308 |
* call site invalidation. If this compiled function is non-optimistic, then it returns the same value as |
|
309 |
* {@link #getConstructor()}. However, if the function is optimistic, then this handle will incur an overhead as it |
|
310 |
* will add an intermediate internal call site that can relink itself when the function needs to regenerate its code |
|
311 |
* to always point at the latest generated code version. |
|
312 |
* @return a guaranteed composable constructor method handle for this function. |
|
313 |
*/ |
|
314 |
MethodHandle createComposableConstructor() { |
|
315 |
return createComposableInvoker(true); |
|
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
316 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
317 |
|
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
318 |
boolean hasConstructor() { |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
319 |
return constructor != null; |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
320 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
321 |
|
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
322 |
MethodType type() { |
24719 | 323 |
return invoker.type(); |
20570
b1c8d1e8013a
8025965: Specialized functions with same weight replace each other in TreeSet
hannesw
parents:
17756
diff
changeset
|
324 |
} |
b1c8d1e8013a
8025965: Specialized functions with same weight replace each other in TreeSet
hannesw
parents:
17756
diff
changeset
|
325 |
|
24719 | 326 |
int weight() { |
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
327 |
return weight(type()); |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
328 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
329 |
|
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
330 |
private static int weight(final MethodType type) { |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
331 |
if (isVarArgsType(type)) { |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
332 |
return Integer.MAX_VALUE; //if there is a varargs it should be the heavist and last fallback |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
333 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
334 |
|
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
335 |
int weight = Type.typeFor(type.returnType()).getWeight(); |
24719 | 336 |
for (int i = 0 ; i < type.parameterCount() ; i++) { |
337 |
final Class<?> paramType = type.parameterType(i); |
|
17518
2225a4f929c0
8013477: Node.setSymbol needs to be copy on write - enable IR snapshots for recompilation based on callsite type specialization. [not enabled by default, hidden by a flag for now]
lagergren
parents:
16523
diff
changeset
|
338 |
final int pweight = Type.typeFor(paramType).getWeight() * 2; //params are more important than call types as return values are always specialized |
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
339 |
weight += pweight; |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
340 |
} |
24719 | 341 |
|
342 |
weight += type.parameterCount(); //more params outweigh few parameters |
|
343 |
||
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
344 |
return weight; |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
345 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
346 |
|
24738
be2026c9717c
8039746: Transform applies to calls wherever possible, for ScriptFunctions and JSObjects.
lagergren
parents:
24731
diff
changeset
|
347 |
static boolean isVarArgsType(final MethodType type) { |
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
348 |
assert type.parameterCount() >= 1 : type; |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
349 |
return type.parameterType(type.parameterCount() - 1) == Object[].class; |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
350 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
351 |
|
24719 | 352 |
static boolean moreGenericThan(final MethodType mt0, final MethodType mt1) { |
353 |
return weight(mt0) > weight(mt1); |
|
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
354 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
355 |
|
24719 | 356 |
boolean betterThanFinal(final CompiledFunction other, final MethodType callSiteMethodType) { |
357 |
// Prefer anything over nothing, as we can't compile new versions. |
|
358 |
if (other == null) { |
|
359 |
return true; |
|
360 |
} |
|
26768
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
361 |
return betterThanFinal(this, other, callSiteMethodType); |
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
362 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
363 |
|
26768
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
364 |
private static boolean betterThanFinal(final CompiledFunction cf, final CompiledFunction other, final MethodType callSiteMethodType) { |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
365 |
final MethodType thisMethodType = cf.type(); |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
366 |
final MethodType otherMethodType = other.type(); |
24719 | 367 |
final int thisParamCount = getParamCount(thisMethodType); |
368 |
final int otherParamCount = getParamCount(otherMethodType); |
|
369 |
final int callSiteRawParamCount = getParamCount(callSiteMethodType); |
|
370 |
final boolean csVarArg = callSiteRawParamCount == Integer.MAX_VALUE; |
|
371 |
// Subtract 1 for callee for non-vararg call sites |
|
372 |
final int callSiteParamCount = csVarArg ? callSiteRawParamCount : callSiteRawParamCount - 1; |
|
373 |
||
374 |
// Prefer the function that discards less parameters |
|
375 |
final int thisDiscardsParams = Math.max(callSiteParamCount - thisParamCount, 0); |
|
376 |
final int otherDiscardsParams = Math.max(callSiteParamCount - otherParamCount, 0); |
|
377 |
if(thisDiscardsParams < otherDiscardsParams) { |
|
378 |
return true; |
|
379 |
} |
|
380 |
if(thisDiscardsParams > otherDiscardsParams) { |
|
381 |
return false; |
|
382 |
} |
|
383 |
||
384 |
final boolean thisVarArg = thisParamCount == Integer.MAX_VALUE; |
|
385 |
final boolean otherVarArg = otherParamCount == Integer.MAX_VALUE; |
|
386 |
if(!(thisVarArg && otherVarArg && csVarArg)) { |
|
387 |
// At least one of them isn't vararg |
|
388 |
final Type[] thisType = toTypeWithoutCallee(thisMethodType, 0); // Never has callee |
|
389 |
final Type[] otherType = toTypeWithoutCallee(otherMethodType, 0); // Never has callee |
|
390 |
final Type[] callSiteType = toTypeWithoutCallee(callSiteMethodType, 1); // Always has callee |
|
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
391 |
|
24719 | 392 |
int narrowWeightDelta = 0; |
393 |
int widenWeightDelta = 0; |
|
394 |
final int minParamsCount = Math.min(Math.min(thisParamCount, otherParamCount), callSiteParamCount); |
|
42376
8604f1a50c30
8170322: Specialized functions convert booleans to numbers
hannesw
parents:
34447
diff
changeset
|
395 |
final boolean convertsNumericArgs = cf.convertsNumericArgs(); |
24719 | 396 |
for(int i = 0; i < minParamsCount; ++i) { |
42376
8604f1a50c30
8170322: Specialized functions convert booleans to numbers
hannesw
parents:
34447
diff
changeset
|
397 |
final Type callSiteParamType = getParamType(i, callSiteType, csVarArg); |
8604f1a50c30
8170322: Specialized functions convert booleans to numbers
hannesw
parents:
34447
diff
changeset
|
398 |
final Type thisParamType = getParamType(i, thisType, thisVarArg); |
8604f1a50c30
8170322: Specialized functions convert booleans to numbers
hannesw
parents:
34447
diff
changeset
|
399 |
if (!convertsNumericArgs && callSiteParamType.isBoolean() && thisParamType.isNumeric()) { |
8604f1a50c30
8170322: Specialized functions convert booleans to numbers
hannesw
parents:
34447
diff
changeset
|
400 |
// When an argument is converted to number by a function it is safe to "widen" booleans to numeric types. |
8604f1a50c30
8170322: Specialized functions convert booleans to numbers
hannesw
parents:
34447
diff
changeset
|
401 |
// However, we must avoid this conversion for generic functions such as Array.prototype.push. |
8604f1a50c30
8170322: Specialized functions convert booleans to numbers
hannesw
parents:
34447
diff
changeset
|
402 |
return false; |
8604f1a50c30
8170322: Specialized functions convert booleans to numbers
hannesw
parents:
34447
diff
changeset
|
403 |
} |
8604f1a50c30
8170322: Specialized functions convert booleans to numbers
hannesw
parents:
34447
diff
changeset
|
404 |
final int callSiteParamWeight = callSiteParamType.getWeight(); |
24719 | 405 |
// Delta is negative for narrowing, positive for widening |
42376
8604f1a50c30
8170322: Specialized functions convert booleans to numbers
hannesw
parents:
34447
diff
changeset
|
406 |
final int thisParamWeightDelta = thisParamType.getWeight() - callSiteParamWeight; |
24719 | 407 |
final int otherParamWeightDelta = getParamType(i, otherType, otherVarArg).getWeight() - callSiteParamWeight; |
408 |
// Only count absolute values of narrowings |
|
409 |
narrowWeightDelta += Math.max(-thisParamWeightDelta, 0) - Math.max(-otherParamWeightDelta, 0); |
|
410 |
// Only count absolute values of widenings |
|
411 |
widenWeightDelta += Math.max(thisParamWeightDelta, 0) - Math.max(otherParamWeightDelta, 0); |
|
412 |
} |
|
413 |
||
414 |
// If both functions accept more arguments than what is passed at the call site, account for ability |
|
415 |
// to receive Undefined un-narrowed in the remaining arguments. |
|
416 |
if(!thisVarArg) { |
|
417 |
for(int i = callSiteParamCount; i < thisParamCount; ++i) { |
|
418 |
narrowWeightDelta += Math.max(Type.OBJECT.getWeight() - thisType[i].getWeight(), 0); |
|
419 |
} |
|
420 |
} |
|
421 |
if(!otherVarArg) { |
|
422 |
for(int i = callSiteParamCount; i < otherParamCount; ++i) { |
|
423 |
narrowWeightDelta -= Math.max(Type.OBJECT.getWeight() - otherType[i].getWeight(), 0); |
|
424 |
} |
|
425 |
} |
|
426 |
||
427 |
// Prefer function that narrows less |
|
428 |
if(narrowWeightDelta < 0) { |
|
429 |
return true; |
|
430 |
} |
|
431 |
if(narrowWeightDelta > 0) { |
|
432 |
return false; |
|
433 |
} |
|
434 |
||
435 |
// Prefer function that widens less |
|
436 |
if(widenWeightDelta < 0) { |
|
437 |
return true; |
|
438 |
} |
|
439 |
if(widenWeightDelta > 0) { |
|
440 |
return false; |
|
441 |
} |
|
442 |
} |
|
443 |
||
444 |
// Prefer the function that exactly matches the arity of the call site. |
|
445 |
if(thisParamCount == callSiteParamCount && otherParamCount != callSiteParamCount) { |
|
446 |
return true; |
|
447 |
} |
|
448 |
if(thisParamCount != callSiteParamCount && otherParamCount == callSiteParamCount) { |
|
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
449 |
return false; |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
450 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
451 |
|
24719 | 452 |
// Otherwise, neither function matches arity exactly. We also know that at this point, they both can receive |
453 |
// more arguments than call site, otherwise we would've already chosen the one that discards less parameters. |
|
454 |
// Note that variable arity methods are preferred, as they actually match the call site arity better, since they |
|
455 |
// really have arbitrary arity. |
|
456 |
if(thisVarArg) { |
|
457 |
if(!otherVarArg) { |
|
458 |
return true; // |
|
459 |
} |
|
460 |
} else if(otherVarArg) { |
|
461 |
return false; |
|
462 |
} |
|
463 |
||
464 |
// Neither is variable arity; chose the one that has less extra parameters. |
|
465 |
final int fnParamDelta = thisParamCount - otherParamCount; |
|
466 |
if(fnParamDelta < 0) { |
|
467 |
return true; |
|
468 |
} |
|
469 |
if(fnParamDelta > 0) { |
|
470 |
return false; |
|
471 |
} |
|
472 |
||
473 |
final int callSiteRetWeight = Type.typeFor(callSiteMethodType.returnType()).getWeight(); |
|
474 |
// Delta is negative for narrower return type, positive for wider return type |
|
475 |
final int thisRetWeightDelta = Type.typeFor(thisMethodType.returnType()).getWeight() - callSiteRetWeight; |
|
476 |
final int otherRetWeightDelta = Type.typeFor(otherMethodType.returnType()).getWeight() - callSiteRetWeight; |
|
477 |
||
478 |
// Prefer function that returns a less wide return type |
|
479 |
final int widenRetDelta = Math.max(thisRetWeightDelta, 0) - Math.max(otherRetWeightDelta, 0); |
|
480 |
if(widenRetDelta < 0) { |
|
481 |
return true; |
|
482 |
} |
|
483 |
if(widenRetDelta > 0) { |
|
484 |
return false; |
|
485 |
} |
|
486 |
||
487 |
// Prefer function that returns a less narrow return type |
|
488 |
final int narrowRetDelta = Math.max(-thisRetWeightDelta, 0) - Math.max(-otherRetWeightDelta, 0); |
|
489 |
if(narrowRetDelta < 0) { |
|
490 |
return true; |
|
491 |
} |
|
492 |
if(narrowRetDelta > 0) { |
|
493 |
return false; |
|
494 |
} |
|
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
495 |
|
26768
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
496 |
//if they are equal, pick the specialized one first |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
497 |
if (cf.isSpecialization() != other.isSpecialization()) { |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
498 |
return cf.isSpecialization(); //always pick the specialized version if we can |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
499 |
} |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
500 |
|
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
501 |
if (cf.isSpecialization() && other.isSpecialization()) { |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
502 |
return cf.getLinkLogicClass() != null; //pick link logic specialization above generic specializations |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
503 |
} |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
504 |
|
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
505 |
// Signatures are identical |
751b0f427090
8025435: Optimistic builtins support, implemented initial optimistic versions of push, pop, and charCodeAt
lagergren
parents:
26500
diff
changeset
|
506 |
throw new AssertionError(thisMethodType + " identically applicable to " + otherMethodType + " for " + callSiteMethodType); |
24719 | 507 |
} |
508 |
||
24725
7bb1f687a852
8033334: Make sure that scope depth information is maintained in the RecompilableScriptFunctionDatas, to avoid unnecessary slow proto linkage when doing on demand compilation
lagergren
parents:
24719
diff
changeset
|
509 |
private static Type[] toTypeWithoutCallee(final MethodType type, final int thisIndex) { |
24719 | 510 |
final int paramCount = type.parameterCount(); |
511 |
final Type[] t = new Type[paramCount - thisIndex]; |
|
512 |
for(int i = thisIndex; i < paramCount; ++i) { |
|
513 |
t[i - thisIndex] = Type.typeFor(type.parameterType(i)); |
|
514 |
} |
|
515 |
return t; |
|
516 |
} |
|
517 |
||
24725
7bb1f687a852
8033334: Make sure that scope depth information is maintained in the RecompilableScriptFunctionDatas, to avoid unnecessary slow proto linkage when doing on demand compilation
lagergren
parents:
24719
diff
changeset
|
518 |
private static Type getParamType(final int i, final Type[] paramTypes, final boolean isVarArg) { |
24719 | 519 |
final int fixParamCount = paramTypes.length - (isVarArg ? 1 : 0); |
520 |
if(i < fixParamCount) { |
|
521 |
return paramTypes[i]; |
|
522 |
} |
|
523 |
assert isVarArg; |
|
24738
be2026c9717c
8039746: Transform applies to calls wherever possible, for ScriptFunctions and JSObjects.
lagergren
parents:
24731
diff
changeset
|
524 |
return ((ArrayType)paramTypes[paramTypes.length - 1]).getElementType(); |
24719 | 525 |
} |
526 |
||
26886
18c744ab4df2
8059211: Changed ArrayData.length accessor to use the protected field and fixed javadoc warnings related to this
lagergren
parents:
26768
diff
changeset
|
527 |
boolean matchesCallSite(final MethodType other, final boolean pickVarArg) { |
18c744ab4df2
8059211: Changed ArrayData.length accessor to use the protected field and fixed javadoc warnings related to this
lagergren
parents:
26768
diff
changeset
|
528 |
if (other.equals(this.callSiteType)) { |
26055
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
529 |
return true; |
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
530 |
} |
24738
be2026c9717c
8039746: Transform applies to calls wherever possible, for ScriptFunctions and JSObjects.
lagergren
parents:
24731
diff
changeset
|
531 |
final MethodType type = type(); |
24719 | 532 |
final int fnParamCount = getParamCount(type); |
533 |
final boolean isVarArg = fnParamCount == Integer.MAX_VALUE; |
|
24738
be2026c9717c
8039746: Transform applies to calls wherever possible, for ScriptFunctions and JSObjects.
lagergren
parents:
24731
diff
changeset
|
534 |
if (isVarArg) { |
be2026c9717c
8039746: Transform applies to calls wherever possible, for ScriptFunctions and JSObjects.
lagergren
parents:
24731
diff
changeset
|
535 |
return pickVarArg; |
24719 | 536 |
} |
537 |
||
26886
18c744ab4df2
8059211: Changed ArrayData.length accessor to use the protected field and fixed javadoc warnings related to this
lagergren
parents:
26768
diff
changeset
|
538 |
final int csParamCount = getParamCount(other); |
24719 | 539 |
final boolean csIsVarArg = csParamCount == Integer.MAX_VALUE; |
47232
205e4c0dc8a3
8186646: Nashorn: "duplicate code" assertion when binding a vararg function that just passes arguments along
hannesw
parents:
47216
diff
changeset
|
540 |
if (csIsVarArg && isApplyToCall()) { |
205e4c0dc8a3
8186646: Nashorn: "duplicate code" assertion when binding a vararg function that just passes arguments along
hannesw
parents:
47216
diff
changeset
|
541 |
return false; // apply2call function must be called with exact number of parameters |
205e4c0dc8a3
8186646: Nashorn: "duplicate code" assertion when binding a vararg function that just passes arguments along
hannesw
parents:
47216
diff
changeset
|
542 |
} |
24719 | 543 |
final int thisThisIndex = needsCallee() ? 1 : 0; // Index of "this" parameter in this function's type |
544 |
||
24725
7bb1f687a852
8033334: Make sure that scope depth information is maintained in the RecompilableScriptFunctionDatas, to avoid unnecessary slow proto linkage when doing on demand compilation
lagergren
parents:
24719
diff
changeset
|
545 |
final int fnParamCountNoCallee = fnParamCount - thisThisIndex; |
7bb1f687a852
8033334: Make sure that scope depth information is maintained in the RecompilableScriptFunctionDatas, to avoid unnecessary slow proto linkage when doing on demand compilation
lagergren
parents:
24719
diff
changeset
|
546 |
final int minParams = Math.min(csParamCount - 1, fnParamCountNoCallee); // callSiteType always has callee, so subtract 1 |
30983
d2e4696d58fa
8066220: Fuzzing bug: MethodHandle bug (Object,Object) != (boolean)Object
hannesw
parents:
29538
diff
changeset
|
547 |
// We must match all incoming parameters, including "this". "this" will usually be Object, but there |
d2e4696d58fa
8066220: Fuzzing bug: MethodHandle bug (Object,Object) != (boolean)Object
hannesw
parents:
29538
diff
changeset
|
548 |
// are exceptions, e.g. when calling functions with primitive "this" in strict mode or through call/apply. |
d2e4696d58fa
8066220: Fuzzing bug: MethodHandle bug (Object,Object) != (boolean)Object
hannesw
parents:
29538
diff
changeset
|
549 |
for(int i = 0; i < minParams; ++i) { |
24719 | 550 |
final Type fnType = Type.typeFor(type.parameterType(i + thisThisIndex)); |
26886
18c744ab4df2
8059211: Changed ArrayData.length accessor to use the protected field and fixed javadoc warnings related to this
lagergren
parents:
26768
diff
changeset
|
551 |
final Type csType = csIsVarArg ? Type.OBJECT : Type.typeFor(other.parameterType(i + 1)); |
24719 | 552 |
if(!fnType.isEquivalentTo(csType)) { |
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
553 |
return false; |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
554 |
} |
24719 | 555 |
} |
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
556 |
|
24719 | 557 |
// Must match any undefined parameters to Object type. |
558 |
for(int i = minParams; i < fnParamCountNoCallee; ++i) { |
|
559 |
if(!Type.typeFor(type.parameterType(i + thisThisIndex)).isEquivalentTo(Type.OBJECT)) { |
|
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
560 |
return false; |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
561 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
562 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
563 |
|
24719 | 564 |
return true; |
565 |
} |
|
566 |
||
567 |
private static int getParamCount(final MethodType type) { |
|
568 |
final int paramCount = type.parameterCount(); |
|
569 |
return type.parameterType(paramCount - 1).isArray() ? Integer.MAX_VALUE : paramCount; |
|
570 |
} |
|
571 |
||
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
572 |
private boolean canBeDeoptimized() { |
24719 | 573 |
return optimismInfo != null; |
574 |
} |
|
575 |
||
24725
7bb1f687a852
8033334: Make sure that scope depth information is maintained in the RecompilableScriptFunctionDatas, to avoid unnecessary slow proto linkage when doing on demand compilation
lagergren
parents:
24719
diff
changeset
|
576 |
private MethodHandle createComposableInvoker(final boolean isConstructor) { |
24719 | 577 |
final MethodHandle handle = getInvokerOrConstructor(isConstructor); |
578 |
||
579 |
// If compiled function is not optimistic, it can't ever change its invoker/constructor, so just return them |
|
580 |
// directly. |
|
24751 | 581 |
if(!canBeDeoptimized()) { |
24719 | 582 |
return handle; |
583 |
} |
|
584 |
||
32534
b3ec7f3b3c2a
8136349: Typos patch for nashorn sources submitted on Sep 10, 2015
sundar
parents:
32435
diff
changeset
|
585 |
// Otherwise, we need a new level of indirection; need to introduce a mutable call site that can relink itself |
24719 | 586 |
// to the compiled function's changed target whenever the optimistic assumptions are invalidated. |
587 |
final CallSite cs = new MutableCallSite(handle.type()); |
|
588 |
relinkComposableInvoker(cs, this, isConstructor); |
|
589 |
return cs.dynamicInvoker(); |
|
590 |
} |
|
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
591 |
|
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
592 |
private static class HandleAndAssumptions { |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
593 |
final MethodHandle handle; |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
594 |
final SwitchPoint assumptions; |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
595 |
|
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
596 |
HandleAndAssumptions(final MethodHandle handle, final SwitchPoint assumptions) { |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
597 |
this.handle = handle; |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
598 |
this.assumptions = assumptions; |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
599 |
} |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
600 |
|
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
601 |
GuardedInvocation createInvocation() { |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
602 |
return new GuardedInvocation(handle, assumptions); |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
603 |
} |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
604 |
} |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
605 |
|
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
606 |
/** |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
607 |
* Returns a pair of an invocation created with a passed-in supplier and a non-invalidated switch point for |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
608 |
* optimistic assumptions (or null for the switch point if the function can not be deoptimized). While the method |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
609 |
* makes a best effort to return a non-invalidated switch point (compensating for possible deoptimizing |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
610 |
* recompilation happening on another thread) it is still possible that by the time this method returns the |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
611 |
* switchpoint has been invalidated by a {@code RewriteException} triggered on another thread for this function. |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
612 |
* This is not a problem, though, as these switch points are always used to produce call sites that fall back to |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
613 |
* relinking when they are invalidated, and in this case the execution will end up here again. What this method |
29538
a1bfbabf475c
8075223: revert multithreaded deoptimizing compilation livelock prevention
attila
parents:
29414
diff
changeset
|
614 |
* basically does is minimize such busy-loop relinking while the function is being recompiled on a different thread. |
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
615 |
* @param invocationSupplier the supplier that constructs the actual invocation method handle; should use the |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
616 |
* {@code CompiledFunction} method itself in some capacity. |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
617 |
* @return a tuple object containing the method handle as created by the supplier and an optimistic assumptions |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
618 |
* switch point that is guaranteed to not have been invalidated before the call to this method (or null if the |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
619 |
* function can't be further deoptimized). |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
620 |
*/ |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
621 |
private synchronized HandleAndAssumptions getValidOptimisticInvocation(final Supplier<MethodHandle> invocationSupplier) { |
29538
a1bfbabf475c
8075223: revert multithreaded deoptimizing compilation livelock prevention
attila
parents:
29414
diff
changeset
|
622 |
for(;;) { |
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
623 |
final MethodHandle handle = invocationSupplier.get(); |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
624 |
final SwitchPoint assumptions = canBeDeoptimized() ? optimismInfo.optimisticAssumptions : null; |
29538
a1bfbabf475c
8075223: revert multithreaded deoptimizing compilation livelock prevention
attila
parents:
29414
diff
changeset
|
625 |
if(assumptions != null && assumptions.hasBeenInvalidated()) { |
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
626 |
// We can be in a situation where one thread is in the middle of a deoptimizing compilation when we hit |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
627 |
// this and thus, it has invalidated the old switch point, but hasn't created the new one yet. Note that |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
628 |
// the behavior of invalidating the old switch point before recompilation, and only creating the new one |
29538
a1bfbabf475c
8075223: revert multithreaded deoptimizing compilation livelock prevention
attila
parents:
29414
diff
changeset
|
629 |
// after recompilation is by design. If we didn't wait here for the recompilation to complete, we would |
a1bfbabf475c
8075223: revert multithreaded deoptimizing compilation livelock prevention
attila
parents:
29414
diff
changeset
|
630 |
// be busy looping through the fallback path of the invalidated switch point, relinking the call site |
a1bfbabf475c
8075223: revert multithreaded deoptimizing compilation livelock prevention
attila
parents:
29414
diff
changeset
|
631 |
// again with the same invalidated switch point, invoking the fallback, etc. stealing CPU cycles from |
a1bfbabf475c
8075223: revert multithreaded deoptimizing compilation livelock prevention
attila
parents:
29414
diff
changeset
|
632 |
// the recompilation task we're dependent on. This can still happen if the switch point gets invalidated |
a1bfbabf475c
8075223: revert multithreaded deoptimizing compilation livelock prevention
attila
parents:
29414
diff
changeset
|
633 |
// after we grabbed it here, in which case we'll indeed do one busy relink immediately. |
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
634 |
try { |
29538
a1bfbabf475c
8075223: revert multithreaded deoptimizing compilation livelock prevention
attila
parents:
29414
diff
changeset
|
635 |
wait(); |
26067
b32ccc3a76c9
8055199: Tidy up Nashorn codebase for code standards (August 2014)
attila
parents:
26055
diff
changeset
|
636 |
} catch (final InterruptedException e) { |
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
637 |
// Intentionally ignored. There's nothing meaningful we can do if we're interrupted |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
638 |
} |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
639 |
} else { |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
640 |
return new HandleAndAssumptions(handle, assumptions); |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
641 |
} |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
642 |
} |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
643 |
} |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
644 |
|
24719 | 645 |
private static void relinkComposableInvoker(final CallSite cs, final CompiledFunction inv, final boolean constructor) { |
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
646 |
final HandleAndAssumptions handleAndAssumptions = inv.getValidOptimisticInvocation(new Supplier<MethodHandle>() { |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
647 |
@Override |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
648 |
public MethodHandle get() { |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
649 |
return inv.getInvokerOrConstructor(constructor); |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
650 |
} |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
651 |
}); |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
652 |
final MethodHandle handle = handleAndAssumptions.handle; |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
653 |
final SwitchPoint assumptions = handleAndAssumptions.assumptions; |
24719 | 654 |
final MethodHandle target; |
655 |
if(assumptions == null) { |
|
656 |
target = handle; |
|
657 |
} else { |
|
658 |
final MethodHandle relink = MethodHandles.insertArguments(RELINK_COMPOSABLE_INVOKER, 0, cs, inv, constructor); |
|
659 |
target = assumptions.guardWithTest(handle, MethodHandles.foldArguments(cs.dynamicInvoker(), relink)); |
|
660 |
} |
|
24751 | 661 |
cs.setTarget(target.asType(cs.type())); |
24719 | 662 |
} |
663 |
||
24725
7bb1f687a852
8033334: Make sure that scope depth information is maintained in the RecompilableScriptFunctionDatas, to avoid unnecessary slow proto linkage when doing on demand compilation
lagergren
parents:
24719
diff
changeset
|
664 |
private MethodHandle getInvokerOrConstructor(final boolean selectCtor) { |
24719 | 665 |
return selectCtor ? getConstructor() : createInvokerForPessimisticCaller(); |
666 |
} |
|
667 |
||
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
668 |
/** |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
669 |
* Returns a guarded invocation for this function when not invoked as a constructor. The guarded invocation has no |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
670 |
* guard but it potentially has an optimistic assumptions switch point. As such, it will probably not be used as a |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
671 |
* final guarded invocation, but rather as a holder for an invocation handle and switch point to be decomposed and |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
672 |
* reassembled into a different final invocation by the user of this method. Any recompositions should take care to |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
673 |
* continue to use the switch point. If that is not possible, use {@link #createComposableInvoker()} instead. |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
674 |
* @return a guarded invocation for an ordinary (non-constructor) invocation of this function. |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
675 |
*/ |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
676 |
GuardedInvocation createFunctionInvocation(final Class<?> callSiteReturnType, final int callerProgramPoint) { |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
677 |
return getValidOptimisticInvocation(new Supplier<MethodHandle>() { |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
678 |
@Override |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
679 |
public MethodHandle get() { |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
680 |
return createInvoker(callSiteReturnType, callerProgramPoint); |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
681 |
} |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
682 |
}).createInvocation(); |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
683 |
} |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
684 |
|
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
685 |
/** |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
686 |
* Returns a guarded invocation for this function when invoked as a constructor. The guarded invocation has no guard |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
687 |
* but it potentially has an optimistic assumptions switch point. As such, it will probably not be used as a final |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
688 |
* guarded invocation, but rather as a holder for an invocation handle and switch point to be decomposed and |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
689 |
* reassembled into a different final invocation by the user of this method. Any recompositions should take care to |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
690 |
* continue to use the switch point. If that is not possible, use {@link #createComposableConstructor()} instead. |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
691 |
* @return a guarded invocation for invocation of this function as a constructor. |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
692 |
*/ |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
693 |
GuardedInvocation createConstructorInvocation() { |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
694 |
return getValidOptimisticInvocation(new Supplier<MethodHandle>() { |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
695 |
@Override |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
696 |
public MethodHandle get() { |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
697 |
return getConstructor(); |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
698 |
} |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
699 |
}).createInvocation(); |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
700 |
} |
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
701 |
|
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
702 |
private MethodHandle createInvoker(final Class<?> callSiteReturnType, final int callerProgramPoint) { |
24751 | 703 |
final boolean isOptimistic = canBeDeoptimized(); |
24719 | 704 |
MethodHandle handleRewriteException = isOptimistic ? createRewriteExceptionHandler() : null; |
705 |
||
706 |
MethodHandle inv = invoker; |
|
707 |
if(isValid(callerProgramPoint)) { |
|
708 |
inv = OptimisticReturnFilters.filterOptimisticReturnValue(inv, callSiteReturnType, callerProgramPoint); |
|
24751 | 709 |
inv = changeReturnType(inv, callSiteReturnType); |
24719 | 710 |
if(callSiteReturnType.isPrimitive() && handleRewriteException != null) { |
711 |
// because handleRewriteException always returns Object |
|
712 |
handleRewriteException = OptimisticReturnFilters.filterOptimisticReturnValue(handleRewriteException, |
|
713 |
callSiteReturnType, callerProgramPoint); |
|
714 |
} |
|
715 |
} else if(isOptimistic) { |
|
716 |
// Required so that rewrite exception has the same return type. It'd be okay to do it even if we weren't |
|
717 |
// optimistic, but it isn't necessary as the linker upstream will eventually convert the return type. |
|
718 |
inv = changeReturnType(inv, callSiteReturnType); |
|
719 |
} |
|
720 |
||
721 |
if(isOptimistic) { |
|
722 |
assert handleRewriteException != null; |
|
723 |
final MethodHandle typedHandleRewriteException = changeReturnType(handleRewriteException, inv.type().returnType()); |
|
724 |
return MH.catchException(inv, RewriteException.class, typedHandleRewriteException); |
|
725 |
} |
|
726 |
return inv; |
|
727 |
} |
|
728 |
||
729 |
private MethodHandle createRewriteExceptionHandler() { |
|
730 |
return MH.foldArguments(RESTOF_INVOKER, MH.insertArguments(HANDLE_REWRITE_EXCEPTION, 0, this, optimismInfo)); |
|
731 |
} |
|
732 |
||
24725
7bb1f687a852
8033334: Make sure that scope depth information is maintained in the RecompilableScriptFunctionDatas, to avoid unnecessary slow proto linkage when doing on demand compilation
lagergren
parents:
24719
diff
changeset
|
733 |
private static MethodHandle changeReturnType(final MethodHandle mh, final Class<?> newReturnType) { |
24719 | 734 |
return Bootstrap.getLinkerServices().asType(mh, mh.type().changeReturnType(newReturnType)); |
735 |
} |
|
736 |
||
737 |
@SuppressWarnings("unused") |
|
738 |
private static MethodHandle handleRewriteException(final CompiledFunction function, final OptimismInfo oldOptimismInfo, final RewriteException re) { |
|
739 |
return function.handleRewriteException(oldOptimismInfo, re); |
|
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
740 |
} |
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
741 |
|
24719 | 742 |
/** |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
743 |
* Debug function for printing out all invalidated program points and their |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
744 |
* invalidation mapping to next type |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
745 |
* @param ipp |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
746 |
* @return string describing the ipp map |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
747 |
*/ |
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
748 |
private static List<String> toStringInvalidations(final Map<Integer, Type> ipp) { |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
749 |
if (ipp == null) { |
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
750 |
return Collections.emptyList(); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
751 |
} |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
752 |
|
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
753 |
final List<String> list = new ArrayList<>(); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
754 |
|
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
755 |
for (final Iterator<Map.Entry<Integer, Type>> iter = ipp.entrySet().iterator(); iter.hasNext(); ) { |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
756 |
final Map.Entry<Integer, Type> entry = iter.next(); |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
757 |
final char bct = entry.getValue().getBytecodeStackType(); |
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
758 |
final String type; |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
759 |
|
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
760 |
switch (entry.getValue().getBytecodeStackType()) { |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
761 |
case 'A': |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
762 |
type = "object"; |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
763 |
break; |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
764 |
case 'I': |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
765 |
type = "int"; |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
766 |
break; |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
767 |
case 'J': |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
768 |
type = "long"; |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
769 |
break; |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
770 |
case 'D': |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
771 |
type = "double"; |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
772 |
break; |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
773 |
default: |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
774 |
type = String.valueOf(bct); |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
775 |
break; |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
776 |
} |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
777 |
|
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
778 |
final StringBuilder sb = new StringBuilder(); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
779 |
sb.append('['). |
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
780 |
append("program point: "). |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
781 |
append(entry.getKey()). |
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
782 |
append(" -> "). |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
783 |
append(type). |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
784 |
append(']'); |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
785 |
|
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
786 |
list.add(sb.toString()); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
787 |
} |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
788 |
|
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
789 |
return list; |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
790 |
} |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
791 |
|
26886
18c744ab4df2
8059211: Changed ArrayData.length accessor to use the protected field and fixed javadoc warnings related to this
lagergren
parents:
26768
diff
changeset
|
792 |
private void logRecompile(final String reason, final FunctionNode fn, final MethodType type, final Map<Integer, Type> ipp) { |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
793 |
if (log.isEnabled()) { |
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
794 |
log.info(reason, DebugLogger.quote(fn.getName()), " signature: ", type); |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
795 |
log.indent(); |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
796 |
for (final String str : toStringInvalidations(ipp)) { |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
797 |
log.fine(str); |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
798 |
} |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
799 |
log.unindent(); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
800 |
} |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
801 |
} |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
802 |
|
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
803 |
/** |
24719 | 804 |
* Handles a {@link RewriteException} raised during the execution of this function by recompiling (if needed) the |
805 |
* function with an optimistic assumption invalidated at the program point indicated by the exception, and then |
|
806 |
* executing a rest-of method to complete the execution with the deoptimized version. |
|
25257
c1c2eb19a90e
8047331: Assertion in CompiledFunction when running earley-boyer after Merge
attila
parents:
25236
diff
changeset
|
807 |
* @param oldOptInfo the optimism info of this function. We must store it explicitly as a bound argument in the |
c1c2eb19a90e
8047331: Assertion in CompiledFunction when running earley-boyer after Merge
attila
parents:
25236
diff
changeset
|
808 |
* method handle, otherwise it could be null for handling a rewrite exception in an outer invocation of a recursive |
c1c2eb19a90e
8047331: Assertion in CompiledFunction when running earley-boyer after Merge
attila
parents:
25236
diff
changeset
|
809 |
* function when recursive invocations of the function have completely deoptimized it. |
24719 | 810 |
* @param re the rewrite exception that was raised |
811 |
* @return the method handle for the rest-of method, for folding composition. |
|
812 |
*/ |
|
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
813 |
private synchronized MethodHandle handleRewriteException(final OptimismInfo oldOptInfo, final RewriteException re) { |
24751 | 814 |
if (log.isEnabled()) { |
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
815 |
log.info( |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
816 |
new RecompilationEvent( |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
817 |
Level.INFO, |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
818 |
re, |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
819 |
re.getReturnValueNonDestructive()), |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
820 |
"caught RewriteException ", |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
821 |
re.getMessageShort()); |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
822 |
log.indent(); |
24751 | 823 |
} |
824 |
||
24719 | 825 |
final MethodType type = type(); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
826 |
|
24719 | 827 |
// Compiler needs a call site type as its input, which always has a callee parameter, so we must add it if |
828 |
// this function doesn't have a callee parameter. |
|
27361 | 829 |
final MethodType ct = type.parameterType(0) == ScriptFunction.class ? |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
830 |
type : |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
831 |
type.insertParameterTypes(0, ScriptFunction.class); |
25257
c1c2eb19a90e
8047331: Assertion in CompiledFunction when running earley-boyer after Merge
attila
parents:
25236
diff
changeset
|
832 |
final OptimismInfo currentOptInfo = optimismInfo; |
c1c2eb19a90e
8047331: Assertion in CompiledFunction when running earley-boyer after Merge
attila
parents:
25236
diff
changeset
|
833 |
final boolean shouldRecompile = currentOptInfo != null && currentOptInfo.requestRecompile(re); |
24719 | 834 |
|
25257
c1c2eb19a90e
8047331: Assertion in CompiledFunction when running earley-boyer after Merge
attila
parents:
25236
diff
changeset
|
835 |
// Effective optimism info, for subsequent use. We'll normally try to use the current (latest) one, but if it |
c1c2eb19a90e
8047331: Assertion in CompiledFunction when running earley-boyer after Merge
attila
parents:
25236
diff
changeset
|
836 |
// isn't available, we'll use the old one bound into the call site. |
c1c2eb19a90e
8047331: Assertion in CompiledFunction when running earley-boyer after Merge
attila
parents:
25236
diff
changeset
|
837 |
final OptimismInfo effectiveOptInfo = currentOptInfo != null ? currentOptInfo : oldOptInfo; |
c1c2eb19a90e
8047331: Assertion in CompiledFunction when running earley-boyer after Merge
attila
parents:
25236
diff
changeset
|
838 |
FunctionNode fn = effectiveOptInfo.reparse(); |
32435
cfd619ef23a6
8133300: Ensure symbol table immutability in Nashorn AST
attila
parents:
31548
diff
changeset
|
839 |
final boolean cached = fn.isCached(); |
27361 | 840 |
final Compiler compiler = effectiveOptInfo.getCompiler(fn, ct, re); //set to non rest-of |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
841 |
|
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
842 |
if (!shouldRecompile) { |
24751 | 843 |
// It didn't necessarily recompile, e.g. for an outer invocation of a recursive function if we already |
844 |
// recompiled a deoptimized version for an inner invocation. |
|
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
845 |
// We still need to do the rest of from the beginning |
27361 | 846 |
logRecompile("Rest-of compilation [STANDALONE] ", fn, ct, effectiveOptInfo.invalidatedProgramPoints); |
32435
cfd619ef23a6
8133300: Ensure symbol table immutability in Nashorn AST
attila
parents:
31548
diff
changeset
|
847 |
return restOfHandle(effectiveOptInfo, compiler.compile(fn, cached ? CompilationPhases.COMPILE_CACHED_RESTOF : CompilationPhases.COMPILE_ALL_RESTOF), currentOptInfo != null); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
848 |
} |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
849 |
|
27361 | 850 |
logRecompile("Deoptimizing recompilation (up to bytecode) ", fn, ct, effectiveOptInfo.invalidatedProgramPoints); |
32435
cfd619ef23a6
8133300: Ensure symbol table immutability in Nashorn AST
attila
parents:
31548
diff
changeset
|
851 |
fn = compiler.compile(fn, cached ? CompilationPhases.RECOMPILE_CACHED_UPTO_BYTECODE : CompilationPhases.COMPILE_UPTO_BYTECODE); |
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
852 |
log.fine("Reusable IR generated"); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
853 |
|
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
854 |
// compile the rest of the function, and install it |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
855 |
log.info("Generating and installing bytecode from reusable IR..."); |
27361 | 856 |
logRecompile("Rest-of compilation [CODE PIPELINE REUSE] ", fn, ct, effectiveOptInfo.invalidatedProgramPoints); |
27206 | 857 |
final FunctionNode normalFn = compiler.compile(fn, CompilationPhases.GENERATE_BYTECODE_AND_INSTALL); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
858 |
|
26055
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
859 |
if (effectiveOptInfo.data.usePersistentCodeCache()) { |
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
860 |
final RecompilableScriptFunctionData data = effectiveOptInfo.data; |
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
861 |
final int functionNodeId = data.getFunctionNodeId(); |
27361 | 862 |
final TypeMap typeMap = data.typeMap(ct); |
26055
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
863 |
final Type[] paramTypes = typeMap == null ? null : typeMap.getParameterTypes(functionNodeId); |
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
864 |
final String cacheKey = CodeStore.getCacheKey(functionNodeId, paramTypes); |
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
865 |
compiler.persistClassInfo(cacheKey, normalFn); |
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
866 |
} |
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
867 |
|
25257
c1c2eb19a90e
8047331: Assertion in CompiledFunction when running earley-boyer after Merge
attila
parents:
25236
diff
changeset
|
868 |
final boolean canBeDeoptimized = normalFn.canBeDeoptimized(); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
869 |
|
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
870 |
if (log.isEnabled()) { |
27529
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
871 |
log.unindent(); |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
872 |
log.info("Done."); |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
873 |
|
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
874 |
log.info("Recompiled '", fn.getName(), "' (", Debug.id(this), ") ", canBeDeoptimized ? "can still be deoptimized." : " is completely deoptimized."); |
eafb7de4648e
8063036: Various pretty printing issues with --log=recompile
lagergren
parents:
27361
diff
changeset
|
875 |
log.finest("Looking up invoker..."); |
24719 | 876 |
} |
877 |
||
25257
c1c2eb19a90e
8047331: Assertion in CompiledFunction when running earley-boyer after Merge
attila
parents:
25236
diff
changeset
|
878 |
final MethodHandle newInvoker = effectiveOptInfo.data.lookup(fn); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
879 |
invoker = newInvoker.asType(type.changeReturnType(newInvoker.type().returnType())); |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
880 |
constructor = null; // Will be regenerated when needed |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
881 |
|
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
882 |
log.info("Done: ", invoker); |
27206 | 883 |
final MethodHandle restOf = restOfHandle(effectiveOptInfo, compiler.compile(fn, CompilationPhases.GENERATE_BYTECODE_AND_INSTALL_RESTOF), canBeDeoptimized); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
884 |
|
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
885 |
// Note that we only adjust the switch point after we set the invoker/constructor. This is important. |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
886 |
if (canBeDeoptimized) { |
25257
c1c2eb19a90e
8047331: Assertion in CompiledFunction when running earley-boyer after Merge
attila
parents:
25236
diff
changeset
|
887 |
effectiveOptInfo.newOptimisticAssumptions(); // Otherwise, set a new switch point. |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
888 |
} else { |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
889 |
optimismInfo = null; // If we got to a point where we no longer have optimistic assumptions, let the optimism info go. |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
890 |
} |
26053
8137f95db5e8
8046026: CompiledFunction.relinkComposableInvoker assert is being hit
attila
parents:
25257
diff
changeset
|
891 |
notifyAll(); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
892 |
|
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
893 |
return restOf; |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
894 |
} |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
895 |
|
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
896 |
private MethodHandle restOfHandle(final OptimismInfo info, final FunctionNode restOfFunction, final boolean canBeDeoptimized) { |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
897 |
assert info != null; |
26055
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
898 |
assert restOfFunction.getCompileUnit().getUnitClassName().contains("restOf"); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
899 |
final MethodHandle restOf = |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
900 |
changeReturnType( |
26055
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
901 |
info.data.lookupCodeMethod( |
fe8be844ba50
8043956: Make code caching work with optimistic typing and lazy compilation
hannesw
parents:
26053
diff
changeset
|
902 |
restOfFunction.getCompileUnit().getCode(), |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
903 |
MH.type(restOfFunction.getReturnType().getTypeClass(), |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
904 |
RewriteException.class)), |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
905 |
Object.class); |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
906 |
|
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
907 |
if (!canBeDeoptimized) { |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
908 |
return restOf; |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
909 |
} |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
910 |
|
24719 | 911 |
// If rest-of is itself optimistic, we must make sure that we can repeat a deoptimization if it, too hits an exception. |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
912 |
return MH.catchException(restOf, RewriteException.class, createRewriteExceptionHandler()); |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
913 |
|
24719 | 914 |
} |
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
915 |
|
24719 | 916 |
private static class OptimismInfo { |
917 |
// TODO: this is pointing to its owning ScriptFunctionData. Re-evaluate if that's okay. |
|
918 |
private final RecompilableScriptFunctionData data; |
|
25236
fac419f1e889
8046921: Deoptimization type information peristence
attila
parents:
24779
diff
changeset
|
919 |
private final Map<Integer, Type> invalidatedProgramPoints; |
24719 | 920 |
private SwitchPoint optimisticAssumptions; |
24745
3a6e1477362b
8041434: Add synchronization to the common global constants structure
lagergren
parents:
24744
diff
changeset
|
921 |
private final DebugLogger log; |
24719 | 922 |
|
25236
fac419f1e889
8046921: Deoptimization type information peristence
attila
parents:
24779
diff
changeset
|
923 |
OptimismInfo(final RecompilableScriptFunctionData data, final Map<Integer, Type> invalidatedProgramPoints) { |
24719 | 924 |
this.data = data; |
24745
3a6e1477362b
8041434: Add synchronization to the common global constants structure
lagergren
parents:
24744
diff
changeset
|
925 |
this.log = data.getLogger(); |
31548
d158ec7e1e30
8130663: 6 fields can be static fields in Global class
sundar
parents:
30983
diff
changeset
|
926 |
this.invalidatedProgramPoints = invalidatedProgramPoints == null ? new TreeMap<>() : invalidatedProgramPoints; |
24719 | 927 |
newOptimisticAssumptions(); |
928 |
} |
|
929 |
||
930 |
private void newOptimisticAssumptions() { |
|
931 |
optimisticAssumptions = new SwitchPoint(); |
|
932 |
} |
|
933 |
||
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
934 |
boolean requestRecompile(final RewriteException e) { |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
935 |
final Type retType = e.getReturnType(); |
24719 | 936 |
final Type previousFailedType = invalidatedProgramPoints.put(e.getProgramPoint(), retType); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
937 |
|
24719 | 938 |
if (previousFailedType != null && !previousFailedType.narrowerThan(retType)) { |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
939 |
final StackTraceElement[] stack = e.getStackTrace(); |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
940 |
final String functionId = stack.length == 0 ? |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
941 |
data.getName() : |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
942 |
stack[0].getClassName() + "." + stack[0].getMethodName(); |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
943 |
|
24744
5290da85fc3d
8038426: Move all loggers from process wide scope into Global scope
lagergren
parents:
24742
diff
changeset
|
944 |
log.info("RewriteException for an already invalidated program point ", e.getProgramPoint(), " in ", functionId, ". This is okay for a recursive function invocation, but a bug otherwise."); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
945 |
|
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
946 |
return false; |
24719 | 947 |
} |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
948 |
|
24719 | 949 |
SwitchPoint.invalidateAll(new SwitchPoint[] { optimisticAssumptions }); |
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
950 |
|
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
951 |
return true; |
24719 | 952 |
} |
953 |
||
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
954 |
Compiler getCompiler(final FunctionNode fn, final MethodType actualCallSiteType, final RewriteException e) { |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
955 |
return data.getCompiler(fn, actualCallSiteType, e.getRuntimeScope(), invalidatedProgramPoints, getEntryPoints(e)); |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
956 |
} |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
957 |
|
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
958 |
private static int[] getEntryPoints(final RewriteException e) { |
24719 | 959 |
final int[] prevEntryPoints = e.getPreviousContinuationEntryPoints(); |
960 |
final int[] entryPoints; |
|
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
961 |
if (prevEntryPoints == null) { |
24719 | 962 |
entryPoints = new int[1]; |
963 |
} else { |
|
964 |
final int l = prevEntryPoints.length; |
|
965 |
entryPoints = new int[l + 1]; |
|
966 |
System.arraycopy(prevEntryPoints, 0, entryPoints, 1, l); |
|
967 |
} |
|
968 |
entryPoints[0] = e.getProgramPoint(); |
|
24759
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
969 |
return entryPoints; |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
970 |
} |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
971 |
|
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
972 |
FunctionNode reparse() { |
31aed7d9c02a
8034206: Make parts of code pipeline reusable in order to facilitate faster warmup and faster lazy compilation.
lagergren
parents:
24751
diff
changeset
|
973 |
return data.reparse(); |
24719 | 974 |
} |
975 |
} |
|
976 |
||
977 |
@SuppressWarnings("unused") |
|
978 |
private static Object newFilter(final Object result, final Object allocation) { |
|
979 |
return (result instanceof ScriptObject || !JSType.isPrimitive(result))? result : allocation; |
|
980 |
} |
|
981 |
||
982 |
private static MethodHandle findOwnMH(final String name, final Class<?> rtype, final Class<?>... types) { |
|
983 |
return MH.findStatic(MethodHandles.lookup(), CompiledFunction.class, name, MH.type(rtype, types)); |
|
984 |
} |
|
16523
af8b30edebce
8009718: Lazy execution architecture continued - ScriptFunctionData is either final or recompilable. Moved ScriptFunctionData creation logic away from runtime to compile time. Prepared for method generation/specialization. Got rid of ScriptFunctionImplTrampoline whose semantics could be done as part of the relinking anyway. Merge with the lookup package change.
lagergren
parents:
diff
changeset
|
985 |
} |