Skip to content
Permalink

Comparing changes

Choose two branches to see what’s changed or to start a new pull request. If you need to, you can also or learn more about diff comparisons.

Open a pull request

Create a new pull request by comparing changes across two branches. If you need to, you can also . Learn more about diff comparisons here.
base repository: jruby/jruby
Failed to load repositories. Confirm that selected base ref is valid, then try again.
Loading
base: 93660dc92650
Choose a base ref
...
head repository: jruby/jruby
Failed to load repositories. Confirm that selected head ref is valid, then try again.
Loading
compare: 067e03cdfbe8
Choose a head ref
  • 2 commits
  • 19 files changed
  • 1 contributor

Commits on Aug 3, 2016

  1. Copy the full SHA
    ddaafdf View commit details
  2. [Truffle] Remove all usages of getInstanceFactory() or make sure they…

    … are behind a boundary.
    
    * The factory needs to be constant for newInstance() to compile well.
    eregon committed Aug 3, 2016
    Copy the full SHA
    067e03c View commit details
Showing with 146 additions and 131 deletions.
  1. +3 −0 truffle/src/main/java/org/jruby/truffle/Layouts.java
  2. +3 −1 truffle/src/main/java/org/jruby/truffle/RubyContext.java
  3. +72 −25 truffle/src/main/java/org/jruby/truffle/core/CoreLibrary.java
  4. +6 −17 truffle/src/main/java/org/jruby/truffle/core/encoding/EncodingConverterNodes.java
  5. +4 −4 truffle/src/main/java/org/jruby/truffle/core/encoding/EncodingManager.java
  6. +19 −5 truffle/src/main/java/org/jruby/truffle/core/exception/CoreExceptions.java
  7. +4 −8 truffle/src/main/java/org/jruby/truffle/core/exception/ExceptionOperations.java
  8. +1 −4 truffle/src/main/java/org/jruby/truffle/core/kernel/KernelNodes.java
  9. +6 −2 truffle/src/main/java/org/jruby/truffle/core/queue/SizedQueueNodes.java
  10. +2 −1 truffle/src/main/java/org/jruby/truffle/core/regexp/InterpolatedRegexpNode.java
  11. +9 −12 truffle/src/main/java/org/jruby/truffle/core/regexp/RegexpNodes.java
  12. +0 −31 truffle/src/main/java/org/jruby/truffle/core/rubinius/ChannelPrimitiveNodes.java
  13. +2 −0 truffle/src/main/java/org/jruby/truffle/core/string/StringNodes.java
  14. +4 −12 truffle/src/main/java/org/jruby/truffle/core/symbol/SymbolTable.java
  15. +0 −5 truffle/src/main/java/org/jruby/truffle/language/RubyBaseNode.java
  16. +4 −0 truffle/src/main/java/org/jruby/truffle/language/objects/AllocateObjectNode.java
  17. +1 −1 truffle/src/main/java/org/jruby/truffle/language/parser/jruby/BodyTranslator.java
  18. +5 −2 truffle/src/main/java/org/jruby/truffle/stdlib/bigdecimal/BigDecimalNodes.java
  19. +1 −1 truffle/src/main/java/org/jruby/truffle/stdlib/digest/DigestNodes.java
3 changes: 3 additions & 0 deletions truffle/src/main/java/org/jruby/truffle/Layouts.java
Original file line number Diff line number Diff line change
@@ -84,6 +84,8 @@
import org.jruby.truffle.core.string.StringLayoutImpl;
import org.jruby.truffle.core.symbol.SymbolLayout;
import org.jruby.truffle.core.symbol.SymbolLayoutImpl;
import org.jruby.truffle.core.thread.ThreadBacktraceLocationLayout;
import org.jruby.truffle.core.thread.ThreadBacktraceLocationLayoutImpl;
import org.jruby.truffle.core.thread.ThreadLayout;
import org.jruby.truffle.core.thread.ThreadLayoutImpl;
import org.jruby.truffle.core.time.TimeLayout;
@@ -136,6 +138,7 @@ public abstract class Layouts {
public static final StringLayout STRING = StringLayoutImpl.INSTANCE;
public static final SymbolLayout SYMBOL = SymbolLayoutImpl.INSTANCE;
public static final ThreadLayout THREAD = ThreadLayoutImpl.INSTANCE;
public static final ThreadBacktraceLocationLayout THREAD_BACKTRACE_LOCATION = ThreadBacktraceLocationLayoutImpl.INSTANCE;
public static final TimeLayout TIME = TimeLayoutImpl.INSTANCE;
public static final UnboundMethodLayout UNBOUND_METHOD = UnboundMethodLayoutImpl.INSTANCE;
public static final WeakRefLayout WEAK_REF_LAYOUT = WeakRefLayoutImpl.INSTANCE;
4 changes: 3 additions & 1 deletion truffle/src/main/java/org/jruby/truffle/RubyContext.java
Original file line number Diff line number Diff line change
@@ -70,7 +70,7 @@ public class RubyContext extends ExecutionContext {
private final PrimitiveManager primitiveManager = new PrimitiveManager();
private final JRubyInterop jrubyInterop = new JRubyInterop(this);
private final SafepointManager safepointManager = new SafepointManager(this);
private final SymbolTable symbolTable = new SymbolTable(this);
private final SymbolTable symbolTable;
private final InteropManager interopManager = new InteropManager(this);
private final CodeLoader codeLoader = new CodeLoader(this);
private final FeatureLoader featureLoader = new FeatureLoader(this);
@@ -141,6 +141,8 @@ public RubyContext(Ruby jrubyRuntime, TruffleLanguage.Env env) {
coreLibrary = new CoreLibrary(this);
coreLibrary.initialize();

symbolTable = new SymbolTable(coreLibrary.getSymbolFactory());

// Create objects that need core classes

nativePlatform = NativePlatformFactory.createPlatform(this);
97 changes: 72 additions & 25 deletions truffle/src/main/java/org/jruby/truffle/core/CoreLibrary.java
Original file line number Diff line number Diff line change
@@ -161,6 +161,7 @@ public class CoreLibrary {
private final DynamicObject complexClass;
private final DynamicObject dirClass;
private final DynamicObject encodingClass;
private final DynamicObjectFactory encodingFactory;
private final DynamicObject encodingConverterClass;
private final DynamicObject encodingErrorClass;
private final DynamicObject exceptionClass;
@@ -179,10 +180,13 @@ public class CoreLibrary {
private final DynamicObject localJumpErrorClass;
private final DynamicObject lookupTableClass;
private final DynamicObject matchDataClass;
private final DynamicObjectFactory matchDataFactory;
private final DynamicObject moduleClass;
private final DynamicObject nameErrorClass;
private final DynamicObjectFactory nameErrorFactory;
private final DynamicObject nilClass;
private final DynamicObject noMethodErrorClass;
private final DynamicObjectFactory noMethodErrorFactory;
private final DynamicObject notImplementedErrorClass;
private final DynamicObject numericClass;
private final DynamicObject objectClass;
@@ -196,6 +200,7 @@ public class CoreLibrary {
private final DynamicObject rangeErrorClass;
private final DynamicObject rationalClass;
private final DynamicObject regexpClass;
private final DynamicObjectFactory regexpFactory;
private final DynamicObject regexpErrorClass;
private final DynamicObject rubyTruffleErrorClass;
private final DynamicObject runtimeErrorClass;
@@ -205,13 +210,15 @@ public class CoreLibrary {
private final DynamicObject stringClass;
private final DynamicObjectFactory stringFactory;
private final DynamicObject symbolClass;
private final DynamicObjectFactory symbolFactory;
private final DynamicObject syntaxErrorClass;
private final DynamicObject systemCallErrorClass;
private final DynamicObject systemExitClass;
private final DynamicObject threadClass;
private final DynamicObjectFactory threadFactory;
private final DynamicObject threadBacktraceClass;
private final DynamicObject threadBacktraceLocationClass;
private final DynamicObjectFactory threadBacktraceLocationFactory;
private final DynamicObject timeClass;
private final DynamicObjectFactory timeFactory;
private final DynamicObject transcodingClass;
@@ -222,7 +229,6 @@ public class CoreLibrary {
private final DynamicObject errnoModule;
private final DynamicObject kernelModule;
private final DynamicObject rubiniusModule;
private final DynamicObject rubiniusChannelClass;
private final DynamicObject rubiniusFFIModule;
private final DynamicObject rubiniusFFIPointerClass;
private final DynamicObject signalModule;
@@ -257,6 +263,7 @@ public class CoreLibrary {
private final DynamicObject nilObject;
private final DynamicObject rubiniusUndefined;
private final DynamicObject digestClass;
private final DynamicObjectFactory digestFactory;

@CompilationFinal private DynamicObject eagainWaitReadable;
@CompilationFinal private DynamicObject eagainWaitWritable;
@@ -397,9 +404,11 @@ public CoreLibrary(RubyContext context) {

// StandardError > NameError
nameErrorClass = defineClass(standardErrorClass, "NameError");
Layouts.CLASS.setInstanceFactoryUnsafe(nameErrorClass, Layouts.NAME_ERROR.createNameErrorShape(nameErrorClass, nameErrorClass));
nameErrorFactory = Layouts.NAME_ERROR.createNameErrorShape(nameErrorClass, nameErrorClass);
Layouts.CLASS.setInstanceFactoryUnsafe(nameErrorClass, nameErrorFactory);
noMethodErrorClass = defineClass(nameErrorClass, "NoMethodError");
Layouts.CLASS.setInstanceFactoryUnsafe(noMethodErrorClass, Layouts.NO_METHOD_ERROR.createNoMethodErrorShape(noMethodErrorClass, noMethodErrorClass));
noMethodErrorFactory = Layouts.NO_METHOD_ERROR.createNoMethodErrorShape(noMethodErrorClass, noMethodErrorClass);
Layouts.CLASS.setInstanceFactoryUnsafe(noMethodErrorClass, noMethodErrorFactory);

// StandardError > SystemCallError
systemCallErrorClass = defineClass(standardErrorClass, "SystemCallError");
@@ -460,7 +469,8 @@ public CoreLibrary(RubyContext context) {
dirClass = defineClass("Dir");
Layouts.CLASS.setInstanceFactoryUnsafe(dirClass, Layouts.DIR.createDirShape(dirClass, dirClass));
encodingClass = defineClass("Encoding");
Layouts.CLASS.setInstanceFactoryUnsafe(encodingClass, Layouts.ENCODING.createEncodingShape(encodingClass, encodingClass));
encodingFactory = Layouts.ENCODING.createEncodingShape(encodingClass, encodingClass);
Layouts.CLASS.setInstanceFactoryUnsafe(encodingClass, encodingFactory);
falseClass = defineClass("FalseClass");
fiberClass = defineClass("Fiber");
fiberFactory = Layouts.FIBER.createFiberShape(fiberClass, fiberClass);
@@ -470,13 +480,16 @@ public CoreLibrary(RubyContext context) {
hashFactory = Layouts.HASH.createHashShape(hashClass, hashClass);
Layouts.CLASS.setInstanceFactoryUnsafe(hashClass, hashFactory);
matchDataClass = defineClass("MatchData");
Layouts.CLASS.setInstanceFactoryUnsafe(matchDataClass, Layouts.MATCH_DATA.createMatchDataShape(matchDataClass, matchDataClass));
matchDataFactory = Layouts.MATCH_DATA.createMatchDataShape(matchDataClass, matchDataClass);
Layouts.CLASS.setInstanceFactoryUnsafe(matchDataClass, matchDataFactory);
methodClass = defineClass("Method");
methodFactory = Layouts.METHOD.createMethodShape(methodClass, methodClass);
Layouts.CLASS.setInstanceFactoryUnsafe(methodClass, methodFactory);
final DynamicObject mutexClass = defineClass("Mutex");
Layouts.CLASS.setInstanceFactoryUnsafe(mutexClass, Layouts.MUTEX.createMutexShape(mutexClass, mutexClass));
nilClass = defineClass("NilClass");
final DynamicObjectFactory nilFactory = alwaysFrozen(Layouts.CLASS.getInstanceFactory(nilClass));
Layouts.CLASS.setInstanceFactoryUnsafe(nilClass, nilFactory);
procClass = defineClass("Proc");
procFactory = Layouts.PROC.createProcShape(procClass, procClass);
Layouts.CLASS.setInstanceFactoryUnsafe(procClass, procFactory);
@@ -490,12 +503,14 @@ public CoreLibrary(RubyContext context) {
intRangeFactory = Layouts.INT_RANGE.createIntRangeShape(rangeClass, rangeClass);
longRangeFactory = Layouts.LONG_RANGE.createLongRangeShape(rangeClass, rangeClass);
regexpClass = defineClass("Regexp");
Layouts.CLASS.setInstanceFactoryUnsafe(regexpClass, Layouts.REGEXP.createRegexpShape(regexpClass, regexpClass));
regexpFactory = Layouts.REGEXP.createRegexpShape(regexpClass, regexpClass);
Layouts.CLASS.setInstanceFactoryUnsafe(regexpClass, regexpFactory);
stringClass = defineClass("String");
stringFactory = Layouts.STRING.createStringShape(stringClass, stringClass);
Layouts.CLASS.setInstanceFactoryUnsafe(stringClass, stringFactory);
symbolClass = defineClass("Symbol");
Layouts.CLASS.setInstanceFactoryUnsafe(symbolClass, alwaysFrozen(Layouts.SYMBOL.createSymbolShape(symbolClass, symbolClass)));
symbolFactory = alwaysFrozen(Layouts.SYMBOL.createSymbolShape(symbolClass, symbolClass));
Layouts.CLASS.setInstanceFactoryUnsafe(symbolClass, symbolFactory);

threadClass = defineClass("Thread");
threadClass.define("@abort_on_exception", false);
@@ -504,7 +519,8 @@ public CoreLibrary(RubyContext context) {

threadBacktraceClass = defineClass(threadClass, objectClass, "Backtrace");
threadBacktraceLocationClass = defineClass(threadBacktraceClass, objectClass, "Location");
Layouts.CLASS.setInstanceFactoryUnsafe(threadBacktraceLocationClass, ThreadBacktraceLocationLayoutImpl.INSTANCE.createThreadBacktraceLocationShape(threadBacktraceLocationClass, threadBacktraceLocationClass));
threadBacktraceLocationFactory = ThreadBacktraceLocationLayoutImpl.INSTANCE.createThreadBacktraceLocationShape(threadBacktraceLocationClass, threadBacktraceLocationClass);
Layouts.CLASS.setInstanceFactoryUnsafe(threadBacktraceLocationClass, threadBacktraceLocationFactory);
timeClass = defineClass("Time");
timeFactory = Layouts.TIME.createTimeShape(timeClass, timeClass);
Layouts.CLASS.setInstanceFactoryUnsafe(timeClass, timeFactory);
@@ -586,7 +602,6 @@ public CoreLibrary(RubyContext context) {
rubiniusFFIPointerClass = defineClass(rubiniusFFIModule, objectClass, "Pointer");
Layouts.CLASS.setInstanceFactoryUnsafe(rubiniusFFIPointerClass, Layouts.POINTER.createPointerShape(rubiniusFFIPointerClass, rubiniusFFIPointerClass));

rubiniusChannelClass = defineClass(rubiniusModule, objectClass, "Channel");
defineClass(rubiniusModule, objectClass, "Mirror");
defineModule(rubiniusModule, "Type");

@@ -613,15 +628,16 @@ public CoreLibrary(RubyContext context) {

// Create some key objects

mainObject = Layouts.CLASS.getInstanceFactory(objectClass).newInstance();
nilObject = alwaysFrozen(Layouts.CLASS.getInstanceFactory(nilClass)).newInstance();
argv = Layouts.ARRAY.createArray(Layouts.CLASS.getInstanceFactory(arrayClass), null, 0);
rubiniusUndefined = Layouts.CLASS.getInstanceFactory(objectClass).newInstance();
mainObject = objectFactory.newInstance();
nilObject = nilFactory.newInstance();
argv = Layouts.ARRAY.createArray(arrayFactory, null, 0);
rubiniusUndefined = objectFactory.newInstance();

globalVariables = new GlobalVariables(nilObject);

digestClass = defineClass(truffleModule, basicObjectClass, "Digest");
Layouts.CLASS.setInstanceFactoryUnsafe(digestClass, Layouts.DIGEST.createDigestShape(digestClass, digestClass));
digestFactory = Layouts.DIGEST.createDigestShape(digestClass, digestClass);
Layouts.CLASS.setInstanceFactoryUnsafe(digestClass, digestFactory);

// No need for new version since it's null before which is not cached
assert Layouts.CLASS.getSuperclass(basicObjectClass) == null;
@@ -800,11 +816,11 @@ private void initializeGlobalVariables() {
GlobalVariables globals = globalVariables;

loadPathStorage = globals.put("$LOAD_PATH",
Layouts.ARRAY.createArray(Layouts.CLASS.getInstanceFactory(arrayClass), null, 0));
Layouts.ARRAY.createArray(arrayFactory, null, 0));
globals.alias("$:", loadPathStorage);

loadedFeaturesStorage = globals.put("$LOADED_FEATURES",
Layouts.ARRAY.createArray(Layouts.CLASS.getInstanceFactory(arrayClass), null, 0));
Layouts.ARRAY.createArray(arrayFactory, null, 0));
globals.alias("$\"", loadedFeaturesStorage);

globals.put("$,", nilObject);
@@ -917,10 +933,10 @@ private void initializeSignalConstants() {
for (Map.Entry<String, Integer> signal : SignalManager.SIGNALS_LIST.entrySet()) {
DynamicObject signalName = StringOperations.createString(context, StringOperations.encodeRope(signal.getKey(), UTF8Encoding.INSTANCE));
Object[] objects = new Object[]{ signalName, signal.getValue() };
signals[i++] = Layouts.ARRAY.createArray(Layouts.CLASS.getInstanceFactory(arrayClass), objects, objects.length);
signals[i++] = Layouts.ARRAY.createArray(arrayFactory, objects, objects.length);
}

Layouts.MODULE.getFields(signalModule).setConstant(context, node, "SIGNAL_LIST", Layouts.ARRAY.createArray(Layouts.CLASS.getInstanceFactory(arrayClass), signals, signals.length));
Layouts.MODULE.getFields(signalModule).setConstant(context, node, "SIGNAL_LIST", Layouts.ARRAY.createArray(arrayFactory, signals, signals.length));
}

private DynamicObject defineClass(String name) {
@@ -1036,12 +1052,13 @@ public void initializeEncodingConstants() {
getContext().getJRubyRuntime().getEncodingService().defineEncodings(new EncodingService.EncodingDefinitionVisitor() {
@Override
public void defineEncoding(EncodingDB.Entry encodingEntry, byte[] name, int p, int end) {
context.getEncodingManager().defineEncoding(encodingClass, encodingEntry, name, p, end);
context.getEncodingManager().defineEncoding(encodingEntry, name, p, end);
}

@Override
public void defineConstant(int encodingListIndex, String constName) {
Layouts.MODULE.getFields(encodingClass).setConstant(context, node, constName, context.getEncodingManager().getRubyEncoding(encodingListIndex));
final DynamicObject rubyEncoding = context.getEncodingManager().getRubyEncoding(encodingListIndex);
Layouts.MODULE.getFields(encodingClass).setConstant(context, node, constName, rubyEncoding);
}
});

@@ -1053,7 +1070,8 @@ public void defineAlias(int encodingListIndex, String constName) {

@Override
public void defineConstant(int encodingListIndex, String constName) {
Layouts.MODULE.getFields(encodingClass).setConstant(context, node, constName, context.getEncodingManager().getRubyEncoding(encodingListIndex));
final DynamicObject rubyEncoding = context.getEncodingManager().getRubyEncoding(encodingListIndex);
Layouts.MODULE.getFields(encodingClass).setConstant(context, node, constName, rubyEncoding);
}
});
}
@@ -1206,6 +1224,10 @@ public DynamicObject getMatchDataClass() {
return matchDataClass;
}

public DynamicObjectFactory getMatchDataFactory() {
return matchDataFactory;
}

public DynamicObject getModuleClass() {
return moduleClass;
}
@@ -1214,6 +1236,10 @@ public DynamicObject getNameErrorClass() {
return nameErrorClass;
}

public DynamicObjectFactory getNameErrorFactory() {
return nameErrorFactory;
}

public DynamicObject getNilClass() {
return nilClass;
}
@@ -1222,6 +1248,10 @@ public DynamicObject getNoMethodErrorClass() {
return noMethodErrorClass;
}

public DynamicObjectFactory getNoMethodErrorFactory() {
return noMethodErrorFactory;
}

public DynamicObject getObjectClass() {
return objectClass;
}
@@ -1246,6 +1276,10 @@ public DynamicObject getRegexpClass() {
return regexpClass;
}

public DynamicObjectFactory getRegexpFactory() {
return regexpFactory;
}

public DynamicObject getRubyTruffleErrorClass() {
return rubyTruffleErrorClass;
}
@@ -1342,10 +1376,6 @@ public DynamicObject getTranscodingClass() {
return transcodingClass;
}

public DynamicObject getRubiniusChannelClass() {
return rubiniusChannelClass;
}

public DynamicObject getRubiniusFFIPointerClass() {
return rubiniusFFIPointerClass;
}
@@ -1354,6 +1384,7 @@ public DynamicObject getRubiniusUndefined() {
return rubiniusUndefined;
}

@TruffleBoundary
public DynamicObject getErrnoClass(Errno errno) {
return errnoClasses.get(errno);
}
@@ -1362,10 +1393,18 @@ public DynamicObject getSymbolClass() {
return symbolClass;
}

public DynamicObjectFactory getSymbolFactory() {
return symbolFactory;
}

public DynamicObject getThreadBacktraceLocationClass() {
return threadBacktraceLocationClass;
}

public DynamicObjectFactory getThreadBacktraceLocationFactory() {
return threadBacktraceLocationFactory;
}

public DynamicObject getInternalBufferClass() {
return internalBufferClass;
}
@@ -1398,6 +1437,10 @@ public DynamicObject getDigestClass() {
return digestClass;
}

public DynamicObjectFactory getDigestFactory() {
return digestFactory;
}

public DynamicObjectFactory getArrayFactory() {
return arrayFactory;
}
@@ -1486,6 +1529,10 @@ public DynamicObject getRegexpErrorClass() {
return regexpErrorClass;
}

public DynamicObjectFactory getEncodingFactory() {
return encodingFactory;
}

public DynamicObject getEncodingCompatibilityErrorClass() {
return encodingCompatibilityErrorClass;
}
Loading