Mercurial > hg > graal-compiler

comparison graal/com.oracle.truffle.api/src/com/oracle/truffle/api/nodes/DirectCallNode.java @ 15093:5634b199c4da

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Truffle: API-change: renamed CallNode to DirectCallNode and added IndirectCallNode.
author Christian Humer <christian.humer@gmail.com>
date Mon, 14 Apr 2014 20:32:25 +0200
parents graal/com.oracle.truffle.api/src/com/oracle/truffle/api/nodes/CallNode.java@07e7aae05983
children 40d0022115ee
comparison
equal deleted inserted replaced
15092:c73ce0dd3583 15093:5634b199c4da
1 /*
2 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package com.oracle.truffle.api.nodes;
26
27 import com.oracle.truffle.api.*;
28 import com.oracle.truffle.api.frame.*;
29
30 /**
31 * Represents a direct call to a {@link CallTarget}. Direct calls are calls for which the
32 * {@link CallTarget} remains the same for each consecutive call. This part of the Truffle API
33 * enables the runtime system to perform additional optimizations on direct calls.
34 *
35 * Optimizations that can be applied to a {@link DirectCallNode} are inlining and splitting.
36 * Inlining inlines this call site into the call graph of the parent {@link CallTarget}. Splitting
37 * duplicates the {@link CallTarget} using {@link RootNode#split()} to collect call site sensitive
38 * profiling information.
39 *
40 * Please note: This class is not intended to be subclassed by guest language implementations.
41 *
42 * @see IndirectCallNode for calls with a non-constant target
43 * @see TruffleRuntime#createDirectCallNode(CallTarget)
44 * @see #forceInlining()
45 * @see #split()
46 */
47 public abstract class DirectCallNode extends Node {
48
49 protected final CallTarget callTarget;
50
51 protected DirectCallNode(CallTarget callTarget) {
52 this.callTarget = callTarget;
53 }
54
55 /**
56 * Calls the inner {@link CallTarget} returned by {@link #getCurrentCallTarget()}.
57 *
58 * @param arguments the arguments that should be passed to the callee
59 * @return the return result of the call
60 */
61 public abstract Object call(VirtualFrame frame, Object[] arguments);
62
63 /**
64 * Returns the originally supplied {@link CallTarget} when this call node was created. Please
65 * note that the returned {@link CallTarget} is not necessarily the {@link CallTarget} that is
66 * called. For that use {@link #getCurrentCallTarget()} instead.
67 *
68 * @return the {@link CallTarget} provided.
69 */
70 public CallTarget getCallTarget() {
71 return callTarget;
72 }
73
74 /**
75 * Returns <code>true</code> if the underlying runtime system supports inlining for the
76 * {@link CallTarget} in this {@link DirectCallNode}.
77 *
78 * @return true if inlining is supported.
79 */
80 public abstract boolean isInlinable();
81
82 /**
83 * Returns <code>true</code> if the {@link CallTarget} is forced to be inlined. A
84 * {@link DirectCallNode} can either be inlined manually by invoking {@link #forceInlining()} or
85 * by the runtime system which may at any point decide to inline.
86 *
87 * @return true if this method was inlined else false.
88 */
89 public abstract boolean isInliningForced();
90
91 /**
92 * Enforces the runtime system to inline the {@link CallTarget} at this call site. If the
93 * runtime system does not support inlining or it is already inlined this method has no effect.
94 * The runtime system may decide to not inline calls which were forced to inline.
95 */
96 public abstract void forceInlining();
97
98 /**
99 * Returns true if the runtime system has decided to inline this call-site. If the
100 * {@link DirectCallNode} was forced to inline then this does not necessarily mean that the
101 * {@link DirectCallNode} is really going to be inlined. This depends on whether or not the
102 * runtime system supports inlining. The runtime system may also decide to not inline calls
103 * which were forced to inline.
104 */
105 public abstract boolean isInlined();
106
107 /**
108 * Returns <code>true</code> if this {@link DirectCallNode} can be split. A
109 * {@link DirectCallNode} can only be split if the runtime system supports splitting and if the
110 * {@link RootNode} contained the {@link CallTarget} returns <code>true</code> for
111 * {@link RootNode#isSplittable()}.
112 *
113 * @return <code>true</code> if the target can be split
114 */
115 public abstract boolean isSplittable();
116
117 /**
118 * Enforces the runtime system to split the {@link CallTarget}. If the {@link DirectCallNode} is
119 * not splittable this methods has no effect.
120 */
121 public abstract boolean split();
122
123 /**
124 * Returns <code>true</code> if the target of the {@link DirectCallNode} was split.
125 *
126 * @return if the target was split
127 */
128 public final boolean isSplit() {
129 return getSplitCallTarget() != null;
130 }
131
132 /**
133 * Returns the split {@link CallTarget} if this method is split.
134 *
135 * @return the split {@link CallTarget}
136 */
137 public abstract CallTarget getSplitCallTarget();
138
139 /**
140 * Returns the used call target when {@link #call(VirtualFrame, Object[])} is invoked. If the
141 * {@link CallTarget} was split this method returns the {@link CallTarget} returned by
142 * {@link #getSplitCallTarget()}.
143 *
144 * @return the used {@link CallTarget} when node is called
145 */
146 public CallTarget getCurrentCallTarget() {
147 CallTarget split = getSplitCallTarget();
148 if (split != null) {
149 return split;
150 } else {
151 return getCallTarget();
152 }
153 }
154
155 /**
156 * Returns the {@link RootNode} associated with {@link CallTarget} returned by
157 * {@link #getCurrentCallTarget()}. If the stored {@link CallTarget} does not contain a
158 * {@link RootNode} this method returns <code>null</code>.
159 *
160 * @see #getCurrentCallTarget()
161 * @return the root node of the used call target
162 */
163 public final RootNode getCurrentRootNode() {
164 CallTarget target = getCurrentCallTarget();
165 if (target instanceof RootCallTarget) {
166 return ((RootCallTarget) target).getRootNode();
167 }
168 return null;
169 }
170 }