Skip to content

Commit 8256123

Browse files
horakivohorakivo
committed
SymbolToByteOrderNode supports DSL inlining
1 parent a3545b5 commit 8256123

File tree

2 files changed

+64
-95
lines changed

2 files changed

+64
-95
lines changed

‎src/main/java/org/truffleruby/interop/InteropNodes.java

Lines changed: 50 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,6 @@
1212
import java.io.IOException;
1313
import java.lang.reflect.Method;
1414
import java.lang.reflect.Modifier;
15-
import java.nio.ByteOrder;
1615
import java.util.ArrayList;
1716
import java.util.List;
1817
import java.util.Map;
@@ -62,7 +61,6 @@
6261
import com.oracle.truffle.api.TruffleLanguage;
6362
import com.oracle.truffle.api.dsl.Cached;
6463
import com.oracle.truffle.api.dsl.Cached.Shared;
65-
import com.oracle.truffle.api.dsl.CreateCast;
6664
import com.oracle.truffle.api.dsl.GenerateUncached;
6765
import com.oracle.truffle.api.dsl.ImportStatic;
6866
import com.oracle.truffle.api.dsl.NodeChild;
@@ -2237,16 +2235,14 @@ protected Object writeBufferByte(Object receiver, long byteOffset, Object value,
22372235
@NodeChild(value = "byteOffset", type = RubyNode.class)
22382236
public abstract static class ReadBufferShortNode extends CoreMethodNode {
22392237

2240-
@CreateCast("byteOrder")
2241-
protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) {
2242-
return SymbolToByteOrderNode.create(byteOrder);
2243-
}
2244-
22452238
@Specialization(limit = "getInteropCacheLimit()")
2246-
protected short readBufferShort(Object receiver, ByteOrder byteOrder, long byteOffset,
2239+
protected static short readBufferShort(Object receiver, Object byteOrderObject, long byteOffset,
22472240
@CachedLibrary("receiver") InteropLibrary interop,
2248-
@Cached TranslateInteropExceptionNode translateInteropException) {
2241+
@Cached SymbolToByteOrderNode symbolToByteOrderNode,
2242+
@Cached TranslateInteropExceptionNode translateInteropException,
2243+
@Bind("this") Node node) {
22492244
try {
2245+
final var byteOrder = symbolToByteOrderNode.execute(node, byteOrderObject);
22502246
return interop.readBufferShort(receiver, byteOrder, byteOffset);
22512247
} catch (InteropException e) {
22522248
throw translateInteropException.execute(e);
@@ -2262,17 +2258,15 @@ protected short readBufferShort(Object receiver, ByteOrder byteOrder, long byteO
22622258
@NodeChild(value = "value", type = RubyNode.class)
22632259
public abstract static class WriteBufferShortNode extends CoreMethodNode {
22642260

2265-
@CreateCast("byteOrder")
2266-
protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) {
2267-
return SymbolToByteOrderNode.create(byteOrder);
2268-
}
2269-
22702261
@Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInShort(value)")
2271-
protected Object writeBufferShort(Object receiver, ByteOrder byteOrder, long byteOffset, Object value,
2262+
protected static Object writeBufferShort(Object receiver, Object byteOrderObject, long byteOffset, Object value,
22722263
@CachedLibrary("receiver") InteropLibrary interop,
22732264
@CachedLibrary("value") InteropLibrary interopValue,
2274-
@Cached TranslateInteropExceptionNode translateInteropException) {
2265+
@Cached SymbolToByteOrderNode symbolToByteOrderNode,
2266+
@Cached TranslateInteropExceptionNode translateInteropException,
2267+
@Bind("this") Node node) {
22752268
try {
2269+
final var byteOrder = symbolToByteOrderNode.execute(node, byteOrderObject);
22762270
final short shortValue = interopValue.asShort(value);
22772271
interop.writeBufferShort(receiver, byteOrder, byteOffset, shortValue);
22782272
} catch (InteropException e) {
@@ -2289,16 +2283,14 @@ protected Object writeBufferShort(Object receiver, ByteOrder byteOrder, long byt
22892283
@NodeChild(value = "byteOffset", type = RubyNode.class)
22902284
public abstract static class ReadBufferIntNode extends CoreMethodNode {
22912285

2292-
@CreateCast("byteOrder")
2293-
protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) {
2294-
return SymbolToByteOrderNode.create(byteOrder);
2295-
}
2296-
22972286
@Specialization(limit = "getInteropCacheLimit()")
2298-
protected int readBufferInt(Object receiver, ByteOrder byteOrder, long byteOffset,
2287+
protected static int readBufferInt(Object receiver, Object byteOrderObject, long byteOffset,
22992288
@CachedLibrary("receiver") InteropLibrary interop,
2300-
@Cached TranslateInteropExceptionNode translateInteropException) {
2289+
@Cached SymbolToByteOrderNode symbolToByteOrderNode,
2290+
@Cached TranslateInteropExceptionNode translateInteropException,
2291+
@Bind("this") Node node) {
23012292
try {
2293+
final var byteOrder = symbolToByteOrderNode.execute(node, byteOrderObject);
23022294
return interop.readBufferInt(receiver, byteOrder, byteOffset);
23032295
} catch (InteropException e) {
23042296
throw translateInteropException.execute(e);
@@ -2314,17 +2306,15 @@ protected int readBufferInt(Object receiver, ByteOrder byteOrder, long byteOffse
23142306
@NodeChild(value = "value", type = RubyNode.class)
23152307
public abstract static class WriteBufferIntNode extends CoreMethodNode {
23162308

2317-
@CreateCast("byteOrder")
2318-
protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) {
2319-
return SymbolToByteOrderNode.create(byteOrder);
2320-
}
2321-
23222309
@Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInInt(value)")
2323-
protected Object writeBufferInt(Object receiver, ByteOrder order, long byteOffset, Object value,
2310+
protected static Object writeBufferInt(Object receiver, Object orderObject, long byteOffset, Object value,
23242311
@CachedLibrary("receiver") InteropLibrary interop,
23252312
@CachedLibrary("value") InteropLibrary interopValue,
2326-
@Cached TranslateInteropExceptionNode translateInteropException) {
2313+
@Cached SymbolToByteOrderNode symbolToByteOrderNode,
2314+
@Cached TranslateInteropExceptionNode translateInteropException,
2315+
@Bind("this") Node node) {
23272316
try {
2317+
final var order = symbolToByteOrderNode.execute(node, orderObject);
23282318
final int intValue = interopValue.asInt(value);
23292319
interop.writeBufferInt(receiver, order, byteOffset, intValue);
23302320
} catch (InteropException e) {
@@ -2341,16 +2331,14 @@ protected Object writeBufferInt(Object receiver, ByteOrder order, long byteOffse
23412331
@NodeChild(value = "byteOffset", type = RubyNode.class)
23422332
public abstract static class ReadBufferLongNode extends CoreMethodNode {
23432333

2344-
@CreateCast("byteOrder")
2345-
protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) {
2346-
return SymbolToByteOrderNode.create(byteOrder);
2347-
}
2348-
23492334
@Specialization(limit = "getInteropCacheLimit()")
2350-
protected long readBufferLong(Object receiver, ByteOrder byteOrder, long byteOffset,
2335+
protected static long readBufferLong(Object receiver, Object byteOrderObject, long byteOffset,
23512336
@CachedLibrary("receiver") InteropLibrary interop,
2352-
@Cached TranslateInteropExceptionNode translateInteropException) {
2337+
@Cached SymbolToByteOrderNode symbolToByteOrderNode,
2338+
@Cached TranslateInteropExceptionNode translateInteropException,
2339+
@Bind("this") Node node) {
23532340
try {
2341+
final var byteOrder = symbolToByteOrderNode.execute(node, byteOrderObject);
23542342
return interop.readBufferLong(receiver, byteOrder, byteOffset);
23552343
} catch (InteropException e) {
23562344
throw translateInteropException.execute(e);
@@ -2366,17 +2354,15 @@ protected long readBufferLong(Object receiver, ByteOrder byteOrder, long byteOff
23662354
@NodeChild(value = "value", type = RubyNode.class)
23672355
public abstract static class WriteBufferLongNode extends CoreMethodNode {
23682356

2369-
@CreateCast("byteOrder")
2370-
protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) {
2371-
return SymbolToByteOrderNode.create(byteOrder);
2372-
}
2373-
23742357
@Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInLong(value)")
2375-
protected Object writeBufferLong(Object receiver, ByteOrder order, long byteOffset, Object value,
2358+
protected static Object writeBufferLong(Object receiver, Object orderObject, long byteOffset, Object value,
23762359
@CachedLibrary("receiver") InteropLibrary interop,
23772360
@CachedLibrary("value") InteropLibrary interopValue,
2378-
@Cached TranslateInteropExceptionNode translateInteropException) {
2361+
@Cached SymbolToByteOrderNode symbolToByteOrderNode,
2362+
@Cached TranslateInteropExceptionNode translateInteropException,
2363+
@Bind("this") Node node) {
23792364
try {
2365+
final var order = symbolToByteOrderNode.execute(node, orderObject);
23802366
final long longValue = interopValue.asLong(value);
23812367
interop.writeBufferLong(receiver, order, byteOffset, longValue);
23822368
} catch (InteropException e) {
@@ -2393,17 +2379,15 @@ protected Object writeBufferLong(Object receiver, ByteOrder order, long byteOffs
23932379
@NodeChild(value = "byteOffset", type = RubyNode.class)
23942380
public abstract static class ReadBufferFloatNode extends CoreMethodNode {
23952381

2396-
@CreateCast("byteOrder")
2397-
protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) {
2398-
return SymbolToByteOrderNode.create(byteOrder);
2399-
}
2400-
24012382
// must return double so Ruby nodes can deal with it
24022383
@Specialization(limit = "getInteropCacheLimit()")
2403-
protected double readBufferFloat(Object receiver, ByteOrder byteOrder, long byteOffset,
2384+
protected static double readBufferFloat(Object receiver, Object byteOrderObject, long byteOffset,
24042385
@CachedLibrary("receiver") InteropLibrary interop,
2405-
@Cached TranslateInteropExceptionNode translateInteropException) {
2386+
@Cached SymbolToByteOrderNode symbolToByteOrderNode,
2387+
@Cached TranslateInteropExceptionNode translateInteropException,
2388+
@Bind("this") Node node) {
24062389
try {
2390+
final var byteOrder = symbolToByteOrderNode.execute(node, byteOrderObject);
24072391
return interop.readBufferFloat(receiver, byteOrder, byteOffset);
24082392
} catch (InteropException e) {
24092393
throw translateInteropException.execute(e);
@@ -2419,17 +2403,15 @@ protected double readBufferFloat(Object receiver, ByteOrder byteOrder, long byte
24192403
@NodeChild(value = "value", type = RubyNode.class)
24202404
public abstract static class WriteBufferFloatNode extends CoreMethodNode {
24212405

2422-
@CreateCast("byteOrder")
2423-
protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) {
2424-
return SymbolToByteOrderNode.create(byteOrder);
2425-
}
2426-
24272406
@Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInDouble(value)")
2428-
protected Object writeBufferFloat(Object receiver, ByteOrder order, long byteOffset, Object value,
2407+
protected static Object writeBufferFloat(Object receiver, Object orderObject, long byteOffset, Object value,
24292408
@CachedLibrary("receiver") InteropLibrary interop,
24302409
@CachedLibrary("value") InteropLibrary interopValue,
2431-
@Cached TranslateInteropExceptionNode translateInteropException) {
2410+
@Cached SymbolToByteOrderNode symbolToByteOrderNode,
2411+
@Cached TranslateInteropExceptionNode translateInteropException,
2412+
@Bind("this") Node node) {
24322413
try {
2414+
final var order = symbolToByteOrderNode.execute(node, orderObject);
24332415
final float floatValue = (float) interopValue.asDouble(value);
24342416
interop.writeBufferFloat(receiver, order, byteOffset, floatValue);
24352417
} catch (InteropException e) {
@@ -2446,16 +2428,14 @@ protected Object writeBufferFloat(Object receiver, ByteOrder order, long byteOff
24462428
@NodeChild(value = "byteOffset", type = RubyNode.class)
24472429
public abstract static class ReadBufferDoubleNode extends CoreMethodNode {
24482430

2449-
@CreateCast("byteOrder")
2450-
protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) {
2451-
return SymbolToByteOrderNode.create(byteOrder);
2452-
}
2453-
24542431
@Specialization(limit = "getInteropCacheLimit()")
2455-
protected double readBufferDouble(Object receiver, ByteOrder byteOrder, long byteOffset,
2432+
protected static double readBufferDouble(Object receiver, Object byteOrderObject, long byteOffset,
24562433
@CachedLibrary("receiver") InteropLibrary interop,
2457-
@Cached TranslateInteropExceptionNode translateInteropException) {
2434+
@Cached SymbolToByteOrderNode symbolToByteOrderNode,
2435+
@Cached TranslateInteropExceptionNode translateInteropException,
2436+
@Bind("this") Node node) {
24582437
try {
2438+
final var byteOrder = symbolToByteOrderNode.execute(node, byteOrderObject);
24592439
return interop.readBufferDouble(receiver, byteOrder, byteOffset);
24602440
} catch (InteropException e) {
24612441
throw translateInteropException.execute(e);
@@ -2471,17 +2451,15 @@ protected double readBufferDouble(Object receiver, ByteOrder byteOrder, long byt
24712451
@NodeChild(value = "value", type = RubyNode.class)
24722452
public abstract static class WriteBufferDoubleNode extends CoreMethodNode {
24732453

2474-
@CreateCast("byteOrder")
2475-
protected RubyNode coerceSymbolToByteOrder(RubyNode byteOrder) {
2476-
return SymbolToByteOrderNode.create(byteOrder);
2477-
}
2478-
24792454
@Specialization(limit = "getInteropCacheLimit()", guards = "interopValue.fitsInDouble(value)")
2480-
protected Object writeBufferDouble(Object receiver, ByteOrder order, long byteOffset, Object value,
2455+
protected static Object writeBufferDouble(Object receiver, Object orderObject, long byteOffset, Object value,
24812456
@CachedLibrary("receiver") InteropLibrary interop,
24822457
@CachedLibrary("value") InteropLibrary interopValue,
2483-
@Cached TranslateInteropExceptionNode translateInteropException) {
2458+
@Cached SymbolToByteOrderNode symbolToByteOrderNode,
2459+
@Cached TranslateInteropExceptionNode translateInteropException,
2460+
@Bind("this") Node node) {
24842461
try {
2462+
final var order = symbolToByteOrderNode.execute(node, orderObject);
24852463
final double doubleValue = interopValue.asDouble(value);
24862464
interop.writeBufferDouble(receiver, order, byteOffset, doubleValue);
24872465
} catch (InteropException e) {

‎src/main/java/org/truffleruby/interop/SymbolToByteOrderNode.java

Lines changed: 14 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -10,50 +10,41 @@
1010
package org.truffleruby.interop;
1111

1212
import com.oracle.truffle.api.dsl.Fallback;
13-
import com.oracle.truffle.api.dsl.NodeChild;
13+
import com.oracle.truffle.api.dsl.GenerateCached;
14+
import com.oracle.truffle.api.dsl.GenerateInline;
1415
import com.oracle.truffle.api.dsl.Specialization;
16+
import com.oracle.truffle.api.nodes.Node;
1517
import org.truffleruby.core.symbol.RubySymbol;
16-
import org.truffleruby.language.RubyContextSourceNode;
17-
import org.truffleruby.language.RubyNode;
18+
import org.truffleruby.language.RubyBaseNode;
1819
import org.truffleruby.language.control.RaiseException;
1920

2021
import java.nio.ByteOrder;
2122

22-
@NodeChild(value = "valueNode", type = RubyNode.class)
23-
public abstract class SymbolToByteOrderNode extends RubyContextSourceNode {
23+
@GenerateInline
24+
@GenerateCached(false)
25+
public abstract class SymbolToByteOrderNode extends RubyBaseNode {
2426

25-
public static SymbolToByteOrderNode create(RubyNode value) {
26-
return SymbolToByteOrderNodeGen.create(value);
27-
}
28-
29-
abstract RubyNode getValueNode();
27+
public abstract ByteOrder execute(Node node, Object value);
3028

3129
@Specialization(guards = "symbol == coreSymbols().BIG")
32-
protected ByteOrder symbolToByteOrderBig(RubySymbol symbol) {
30+
protected static ByteOrder symbolToByteOrderBig(RubySymbol symbol) {
3331
return ByteOrder.BIG_ENDIAN;
3432
}
3533

3634
@Specialization(guards = "symbol == coreSymbols().LITTLE")
37-
protected ByteOrder symbolToByteOrderLittle(RubySymbol symbol) {
35+
protected static ByteOrder symbolToByteOrderLittle(RubySymbol symbol) {
3836
return ByteOrder.LITTLE_ENDIAN;
3937
}
4038

4139
@Specialization(guards = "symbol == coreSymbols().NATIVE")
42-
protected ByteOrder symbolToByteOrderNative(RubySymbol symbol) {
40+
protected static ByteOrder symbolToByteOrderNative(RubySymbol symbol) {
4341
return ByteOrder.nativeOrder();
4442
}
4543

4644
@Fallback
47-
protected ByteOrder invalidByteOrder(Object value) {
45+
protected static ByteOrder invalidByteOrder(Node node, Object value) {
4846
throw new RaiseException(
49-
getContext(),
50-
coreExceptions().argumentError("byte order must be :big, :little, or :native symbol", this));
47+
getContext(node),
48+
coreExceptions(node).argumentError("byte order must be :big, :little, or :native symbol", node));
5149
}
52-
53-
@Override
54-
public RubyNode cloneUninitialized() {
55-
var copy = SymbolToByteOrderNodeGen.create(getValueNode().cloneUninitialized());
56-
return copy.copyFlags(this);
57-
}
58-
5950
}

0 commit comments

Comments
 (0)