Merge branch 'master' into truffle-head

Conflicts: truffle/src/main/java/org/jruby/truffle/nodes/control/TraceNode.java truffle/src/main/java/org/jruby/truffle/nodes/core/MethodNodes.java truffle/src/main/java/org/jruby/truffle/nodes/core/ThreadBacktraceLocationNodes.java truffle/src/main/java/org/jruby/truffle/nodes/core/UnboundMethodNodes.java truffle/src/main/java/org/jruby/truffle/nodes/interop/InteropNode.java truffle/src/main/java/org/jruby/truffle/runtime/RubyObjectType.java
jruby · Aug 18, 2015 · 26517c4 · 26517c4
2 parents 617b69f + 7032f34
commit 26517c4
Showing 192 changed files with 3,822 additions and 3,543 deletions.
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/RubyGuards.java b/truffle/src/main/java/org/jruby/truffle/nodes/RubyGuards.java
@@ -11,14 +11,12 @@
 
 import com.oracle.truffle.api.interop.TruffleObject;
 import com.oracle.truffle.api.object.DynamicObject;
-import org.jruby.truffle.nodes.core.*;
-import org.jruby.truffle.nodes.core.array.ArrayNodes;
-import org.jruby.truffle.nodes.core.hash.HashNodes;
-import org.jruby.truffle.nodes.ext.BigDecimalNodes;
-import org.jruby.truffle.nodes.rubinius.ByteArrayNodes;
-import org.jruby.truffle.nodes.rubinius.PointerNodes;
 import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.ThreadLocalObject;
+import org.jruby.truffle.runtime.layouts.Layouts;
+import org.jruby.truffle.runtime.layouts.ThreadLayoutImpl;
+import org.jruby.truffle.runtime.layouts.TimeLayoutImpl;
+import org.jruby.truffle.runtime.layouts.rubinius.ByteArrayLayoutImpl;
 
 public abstract class RubyGuards {
 
@@ -43,203 +41,179 @@ public static boolean isDouble(Object value) {
     // Ruby types
 
     public static boolean isRubyBasicObject(Object object) {
-        return BasicObjectNodes.BASIC_OBJECT_LAYOUT.isBasicObject(object);
+        return Layouts.BASIC_OBJECT.isBasicObject(object);
     }
 
     public static boolean isRubyBignum(Object value) {
-        return (value instanceof DynamicObject) && isRubyBignum((DynamicObject) value);
+        return Layouts.BIGNUM.isBignum(value);
     }
 
     public static boolean isRubyBignum(DynamicObject value) {
-        return BignumNodes.BIGNUM_LAYOUT.isBignum(value);
+        return Layouts.BIGNUM.isBignum(value);
     }
 
     public static boolean isRubyBigDecimal(DynamicObject value) {
-        return BigDecimalNodes.BIG_DECIMAL_LAYOUT.isBigDecimal(value);
+        return Layouts.BIG_DECIMAL.isBigDecimal(value);
     }
 
     public static boolean isIntegerFixnumRange(Object object) {
-        return (object instanceof DynamicObject) && isIntegerFixnumRange((DynamicObject) object);
+        return Layouts.INTEGER_FIXNUM_RANGE.isIntegerFixnumRange(object);
     }
 
     public static boolean isIntegerFixnumRange(DynamicObject object) {
-        return RangeNodes.INTEGER_FIXNUM_RANGE_LAYOUT.isIntegerFixnumRange(object);
+        return Layouts.INTEGER_FIXNUM_RANGE.isIntegerFixnumRange(object);
     }
 
     public static boolean isLongFixnumRange(Object object) {
-        return (object instanceof DynamicObject) && isLongFixnumRange((DynamicObject) object);
+        return Layouts.LONG_FIXNUM_RANGE.isLongFixnumRange(object);
     }
 
     public static boolean isLongFixnumRange(DynamicObject object) {
-        return RangeNodes.LONG_FIXNUM_RANGE_LAYOUT.isLongFixnumRange(object);
+        return Layouts.LONG_FIXNUM_RANGE.isLongFixnumRange(object);
     }
 
     public static boolean isObjectRange(Object object) {
-        return (object instanceof DynamicObject) && isObjectRange((DynamicObject) object);
+        return Layouts.OBJECT_RANGE.isObjectRange(object);
     }
 
     public static boolean isObjectRange(DynamicObject object) {
-        return RangeNodes.OBJECT_RANGE_LAYOUT.isObjectRange(object);
+        return Layouts.OBJECT_RANGE.isObjectRange(object);
     }
 
     public static boolean isRubyRange(Object value) {
         return isIntegerFixnumRange(value) || isLongFixnumRange(value) || isObjectRange(value);
     }
 
     public static boolean isRubyArray(Object value) {
-        return (value instanceof DynamicObject) && isRubyArray((DynamicObject) value);
+        return Layouts.ARRAY.isArray(value);
     }
 
     public static boolean isRubyArray(DynamicObject value) {
-        return ArrayNodes.ARRAY_LAYOUT.isArray(value);
+        return Layouts.ARRAY.isArray(value);
     }
 
     public static boolean isRubyBinding(DynamicObject object) {
-        return BindingNodes.BINDING_LAYOUT.isBinding(object);
+        return Layouts.BINDING.isBinding(object);
     }
 
     public static boolean isRubyClass(Object value) {
-        return (value instanceof DynamicObject) && isRubyClass((DynamicObject) value);
+        return Layouts.CLASS.isClass(value);
     }
 
     public static boolean isRubyClass(DynamicObject value) {
-        return ClassNodes.CLASS_LAYOUT.isClass(value);
+        return Layouts.CLASS.isClass(value);
     }
 
     public static boolean isRubyHash(Object value) {
-        return (value instanceof DynamicObject) && isRubyHash((DynamicObject) value);
+        return Layouts.HASH.isHash(value);
     }
 
     public static boolean isRubyHash(DynamicObject value) {
-        return HashNodes.HASH_LAYOUT.isHash(value);
+        return Layouts.HASH.isHash(value);
     }
 
     public static boolean isRubyModule(Object value) {
-        return (value instanceof DynamicObject) && isRubyModule((DynamicObject) value);
+        return Layouts.MODULE.isModule(value);
     }
 
     public static boolean isRubyModule(DynamicObject value) {
-        return ModuleNodes.MODULE_LAYOUT.isModule(value);
+        return Layouts.MODULE.isModule(value);
     }
 
     public static boolean isRubyRegexp(Object value) {
-        return (value instanceof DynamicObject) && isRubyRegexp((DynamicObject) value);
+        return Layouts.REGEXP.isRegexp(value);
     }
 
     public static boolean isRubyRegexp(DynamicObject value) {
-        return RegexpNodes.REGEXP_LAYOUT.isRegexp(value);
+        return Layouts.REGEXP.isRegexp(value);
     }
 
     public static boolean isRubyString(Object value) {
-        return (value instanceof DynamicObject) && isRubyString((DynamicObject) value);
+        return Layouts.STRING.isString(value);
     }
 
     public static boolean isRubyString(DynamicObject value) {
-        return StringNodes.STRING_LAYOUT.isString(value);
+        return Layouts.STRING.isString(value);
     }
 
     public static boolean isRubyEncoding(Object object) {
-        return (object instanceof DynamicObject) && isRubyEncoding((DynamicObject) object);
+        return Layouts.ENCODING.isEncoding(object);
     }
 
     public static boolean isRubyEncoding(DynamicObject object) {
-        return EncodingNodes.ENCODING_LAYOUT.isEncoding(object);
+        return Layouts.ENCODING.isEncoding(object);
     }
 
     public static boolean isRubySymbol(Object value) {
-        return (value instanceof DynamicObject) && isRubySymbol((DynamicObject) value);
+        return Layouts.SYMBOL.isSymbol(value);
     }
 
     public static boolean isRubySymbol(DynamicObject value) {
-        return SymbolNodes.SYMBOL_LAYOUT.isSymbol(value);
+        return Layouts.SYMBOL.isSymbol(value);
     }
 
     public static boolean isRubyMethod(Object value) {
-        return (value instanceof DynamicObject) && isRubyMethod((DynamicObject) value);
+        return Layouts.METHOD.isMethod(value);
     }
 
     public static boolean isRubyMethod(DynamicObject value) {
-        return MethodNodes.METHOD_LAYOUT.isMethod(value);
+        return Layouts.METHOD.isMethod(value);
     }
 
     public static boolean isRubyUnboundMethod(Object value) {
-        return (value instanceof DynamicObject) && isRubyUnboundMethod((DynamicObject) value);
+        return Layouts.UNBOUND_METHOD.isUnboundMethod(value);
     }
 
     public static boolean isRubyUnboundMethod(DynamicObject value) {
-        return UnboundMethodNodes.UNBOUND_METHOD_LAYOUT.isUnboundMethod(value);
-    }
-
-    public static boolean isRubyMutex(DynamicObject value) {
-        return MutexNodes.MUTEX_LAYOUT.isMutex(value);
+        return Layouts.UNBOUND_METHOD.isUnboundMethod(value);
     }
 
     public static boolean isDynamicObject(Object value) {
         return value instanceof DynamicObject;
     }
 
-    public static boolean isRubyPointer(Object value) {
-        return (value instanceof DynamicObject) && isRubyPointer((DynamicObject) value);
-    }
-
     public static boolean isRubyPointer(DynamicObject value) {
-        return PointerNodes.POINTER_LAYOUT.isPointer(value);
-    }
-
-    public static boolean isRubiniusByteArray(Object value) {
-        return (value instanceof DynamicObject) && isRubiniusByteArray((DynamicObject) value);
+        return Layouts.POINTER.isPointer(value);
     }
 
     public static boolean isRubiniusByteArray(DynamicObject value) {
-        return ByteArrayNodes.BYTE_ARRAY_LAYOUT.isByteArray(value);
+        return Layouts.BYTE_ARRAY.isByteArray(value);
     }
 
     public static boolean isRubyProc(Object object) {
-        return (object instanceof DynamicObject) && isRubyProc((DynamicObject) object);
+        return Layouts.PROC.isProc(object);
     }
 
     public static boolean isRubyProc(DynamicObject object) {
-        return ProcNodes.PROC_LAYOUT.isProc(object);
+        return Layouts.PROC.isProc(object);
     }
 
     public static boolean isRubyEncodingConverter(DynamicObject encodingConverter) {
-        return EncodingConverterNodes.ENCODING_CONVERTER_LAYOUT.isEncodingConverter(encodingConverter);
+        return Layouts.ENCODING_CONVERTER.isEncodingConverter(encodingConverter);
     }
 
     public static boolean isRubyTime(DynamicObject object) {
-        return TimeNodes.TIME_LAYOUT.isTime(object);
-    }
-
-    public static boolean isRubyException(Object value) {
-        return (value instanceof DynamicObject) && isRubyException((DynamicObject) value);
+        return Layouts.TIME.isTime(object);
     }
 
     public static boolean isRubyException(DynamicObject object) {
-        return ExceptionNodes.EXCEPTION_LAYOUT.isException(object);
-    }
-
-    public static boolean isRubyFiber(Object object) {
-        return (object instanceof DynamicObject) && isRubyFiber((DynamicObject) object);
+        return Layouts.EXCEPTION.isException(object);
     }
 
     public static boolean isRubyFiber(DynamicObject object) {
-        return FiberNodes.FIBER_LAYOUT.isFiber(object);
-    }
-
-    public static boolean isRubyThread(Object object) {
-        return (object instanceof DynamicObject) && isRubyThread((DynamicObject) object);
+        return Layouts.FIBER.isFiber(object);
     }
 
     public static boolean isRubyThread(DynamicObject object) {
-        return ThreadNodes.THREAD_LAYOUT.isThread(object);
+        return ThreadLayoutImpl.INSTANCE.isThread(object);
     }
 
     public static boolean isRubyMatchData(Object object) {
-        return (object instanceof DynamicObject) && isRubyMatchData((DynamicObject) object);
+        return Layouts.MATCH_DATA.isMatchData(object);
     }
 
     public static boolean isRubyMatchData(DynamicObject object) {
-        return MatchDataNodes.MATCH_DATA_LAYOUT.isMatchData(object);
+        return Layouts.MATCH_DATA.isMatchData(object);
     }
 
     // Internal types

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/RubyNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/RubyNode.java
@@ -24,16 +24,14 @@
 import jnr.ffi.provider.MemoryManager;
 import jnr.posix.POSIX;
 import org.jcodings.Encoding;
-import org.jruby.truffle.nodes.core.BignumNodes;
 import org.jruby.truffle.nodes.core.BindingNodes;
-import org.jruby.truffle.nodes.core.ClassNodes;
 import org.jruby.truffle.nodes.core.StringNodes;
-import org.jruby.truffle.nodes.core.array.ArrayNodes;
 import org.jruby.truffle.nodes.dispatch.DispatchNode;
 import org.jruby.truffle.nodes.instrument.RubyWrapperNode;
 import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.truffle.runtime.sockets.NativeSockets;
 import org.jruby.util.ByteList;
 
@@ -194,19 +192,19 @@ protected DynamicObject createString(ByteList bytes) {
     }
 
     protected DynamicObject createEmptyArray() {
-        return ArrayNodes.ARRAY_LAYOUT.createArray(getContext().getCoreLibrary().getArrayFactory(), null, 0);
+        return Layouts.ARRAY.createArray(getContext().getCoreLibrary().getArrayFactory(), null, 0);
     }
 
     protected DynamicObject createArrayWith(Object... store) {
-        return ArrayNodes.ARRAY_LAYOUT.createArray(getContext().getCoreLibrary().getArrayFactory(), store, store.length);
+        return Layouts.ARRAY.createArray(getContext().getCoreLibrary().getArrayFactory(), store, store.length);
     }
 
     protected DynamicObject createArray(Object store, int size) {
-        return ArrayNodes.ARRAY_LAYOUT.createArray(getContext().getCoreLibrary().getArrayFactory(), store, size);
+        return Layouts.ARRAY.createArray(getContext().getCoreLibrary().getArrayFactory(), store, size);
     }
 
     protected DynamicObject createBignum(BigInteger value) {
-        return BignumNodes.BIGNUM_LAYOUT.createBignum(getContext().getCoreLibrary().getBignumFactory(), value);
+        return Layouts.BIGNUM.createBignum(getContext().getCoreLibrary().getBignumFactory(), value);
     }
 
     protected POSIX posix() {
@@ -224,7 +222,7 @@ protected static int getCacheLimit() {
     // Helper methods for caching
 
     protected DynamicObjectFactory getInstanceFactory(DynamicObject rubyClass) {
-        return ClassNodes.CLASS_LAYOUT.getInstanceFactory(rubyClass);
+        return Layouts.CLASS.getInstanceFactory(rubyClass);
     }
 
     // Instrumentation

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/StringCachingGuards.java b/truffle/src/main/java/org/jruby/truffle/nodes/StringCachingGuards.java
@@ -11,22 +11,22 @@
 package org.jruby.truffle.nodes;
 
 import com.oracle.truffle.api.object.DynamicObject;
-import org.jruby.truffle.nodes.core.StringNodes;
+import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.util.ByteList;
 
 public abstract class StringCachingGuards {
 
     public static ByteList privatizeByteList(DynamicObject string) {
         if (RubyGuards.isRubyString(string)) {
-            return StringNodes.getByteList(string).dup();
+            return Layouts.STRING.getByteList(string).dup();
         } else {
             return null;
         }
     }
 
     public static boolean byteListsEqual(DynamicObject string, ByteList byteList) {
         if (RubyGuards.isRubyString(string)) {
-            return StringNodes.getByteList(string).equal(byteList);
+            return Layouts.STRING.getByteList(string).equal(byteList);
         } else {
             return false;
         }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/arguments/ReadKeywordRestArgumentNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/arguments/ReadKeywordRestArgumentNode.java
@@ -20,6 +20,7 @@
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.hash.BucketsStrategy;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -77,7 +78,7 @@ private Object lookupRestKeywordArgumentHash(VirtualFrame frame) {
             entries.add(keyValue);
         }
 
-        return BucketsStrategy.create(getContext().getCoreLibrary().getHashClass(), entries, HashNodes.isCompareByIdentity(hash));
+        return BucketsStrategy.create(getContext().getCoreLibrary().getHashClass(), entries, Layouts.HASH.getCompareByIdentity(hash));
     }
 
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/cast/CmpIntNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/cast/CmpIntNode.java
@@ -29,12 +29,11 @@
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyNode;
-import org.jruby.truffle.nodes.core.BignumNodes;
-import org.jruby.truffle.nodes.core.ModuleNodes;
 import org.jruby.truffle.nodes.dispatch.CallDispatchHeadNode;
 import org.jruby.truffle.nodes.dispatch.DispatchHeadNodeFactory;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 /**
  * This is a port of MRI's rb_cmpint, as taken from RubyComparable and broken out into specialized nodes.
@@ -84,7 +83,7 @@ public int cmpLong(long value, Object receiver, Object other) {
 
     @Specialization(guards = "isRubyBignum(value)")
     public int cmpBignum(DynamicObject value, Object receiver, Object other) {
-        return BignumNodes.getBigIntegerValue(value).signum();
+        return Layouts.BIGNUM.getValue(value).signum();
     }
 
     @TruffleBoundary
@@ -93,8 +92,8 @@ public int cmpNil(Object nil, Object receiver, Object other) {
         throw new RaiseException(
             getContext().getCoreLibrary().argumentError(
                 String.format("comparison of %s with %s failed",
-                        ModuleNodes.getFields(getContext().getCoreLibrary().getLogicalClass(receiver)).getName(),
-                        ModuleNodes.getFields(getContext().getCoreLibrary().getLogicalClass(other)).getName()), this)
+                        Layouts.MODULE.getFields(getContext().getCoreLibrary().getLogicalClass(receiver)).getName(),
+                        Layouts.MODULE.getFields(getContext().getCoreLibrary().getLogicalClass(other)).getName()), this)
         );
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/coerce/NameToJavaStringNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/coerce/NameToJavaStringNode.java
@@ -19,11 +19,11 @@
 import org.jruby.truffle.nodes.RubyGuards;
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.core.BasicObjectNodes;
-import org.jruby.truffle.nodes.core.SymbolNodes;
 import org.jruby.truffle.nodes.dispatch.CallDispatchHeadNode;
 import org.jruby.truffle.nodes.dispatch.DispatchHeadNodeFactory;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 /**
  * Take a Symbol or some object accepting #to_str
@@ -43,7 +43,7 @@ public NameToJavaStringNode(RubyContext context, SourceSection sourceSection) {
 
     @Specialization(guards = "isRubySymbol(symbol)")
     public String coerceRubySymbol(DynamicObject symbol) {
-        return SymbolNodes.getString(symbol);
+        return Layouts.SYMBOL.getString(symbol);
     }
 
     @Specialization(guards = "isRubyString(string)")

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/constants/GetConstantNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/constants/GetConstantNode.java
@@ -20,12 +20,12 @@
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.core.KernelNodes.RequireNode;
 import org.jruby.truffle.nodes.core.KernelNodesFactory;
-import org.jruby.truffle.nodes.core.ModuleNodes;
 import org.jruby.truffle.nodes.dispatch.CallDispatchHeadNode;
 import org.jruby.truffle.nodes.dispatch.DispatchHeadNodeFactory;
 import org.jruby.truffle.runtime.RubyConstant;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
+import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.util.IdUtil;
 
 @NodeChildren({ @NodeChild("module"), @NodeChild("name"), @NodeChild("constant") })
@@ -54,12 +54,12 @@ protected Object autoloadConstant(VirtualFrame frame, DynamicObject module, Stri
 
         // The autoload constant must only be removed if everything succeeds.
         // We remove it first to allow lookup to ignore it and add it back if there was a failure.
-        ModuleNodes.getFields(constant.getDeclaringModule()).removeConstant(this, name);
+        Layouts.MODULE.getFields(constant.getDeclaringModule()).removeConstant(this, name);
         try {
             requireNode.require(path);
             return readConstantNode.readConstant(frame, module, name);
         } catch (RaiseException e) {
-            ModuleNodes.getFields(constant.getDeclaringModule()).setAutoloadConstant(this, name, path);
+            Layouts.MODULE.getFields(constant.getDeclaringModule()).setAutoloadConstant(this, name, path);
             throw e;
         }
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/constants/LookupConstantNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/constants/LookupConstantNode.java
@@ -21,12 +21,12 @@
 import com.oracle.truffle.api.source.SourceSection;
 import com.oracle.truffle.api.utilities.ConditionProfile;
 import org.jruby.truffle.nodes.RubyNode;
-import org.jruby.truffle.nodes.core.ModuleNodes;
 import org.jruby.truffle.runtime.LexicalScope;
 import org.jruby.truffle.runtime.ModuleOperations;
 import org.jruby.truffle.runtime.RubyConstant;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 /**
  * Caches {@link ModuleOperations#lookupConstant}
@@ -66,7 +66,7 @@ protected RubyConstant lookupConstant(VirtualFrame frame, DynamicObject module,
     }
 
     public Assumption getUnmodifiedAssumption(DynamicObject module) {
-        return ModuleNodes.getFields(module).getUnmodifiedAssumption();
+        return Layouts.MODULE.getFields(module).getUnmodifiedAssumption();
     }
 
     @TruffleBoundary

diff --git a/...e/src/main/java/org/jruby/truffle/nodes/constants/LookupConstantWithLexicalScopeNode.java b/...e/src/main/java/org/jruby/truffle/nodes/constants/LookupConstantWithLexicalScopeNode.java
@@ -17,12 +17,12 @@
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyNode;
-import org.jruby.truffle.nodes.core.ModuleNodes;
 import org.jruby.truffle.runtime.LexicalScope;
 import org.jruby.truffle.runtime.ModuleOperations;
 import org.jruby.truffle.runtime.RubyConstant;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 public abstract class LookupConstantWithLexicalScopeNode extends RubyNode {
 
@@ -53,7 +53,7 @@ protected RubyConstant lookupConstant(VirtualFrame frame,
     }
 
     public Assumption getUnmodifiedAssumption(DynamicObject module) {
-        return ModuleNodes.getFields(module).getUnmodifiedAssumption();
+        return Layouts.MODULE.getFields(module).getUnmodifiedAssumption();
     }
 
     protected RubyConstant doLookup() {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/constants/WriteConstantNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/constants/WriteConstantNode.java
@@ -15,9 +15,9 @@
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyGuards;
 import org.jruby.truffle.nodes.RubyNode;
-import org.jruby.truffle.nodes.core.ModuleNodes;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 /**
  * Represents writing a constant into some module.
@@ -51,7 +51,7 @@ public Object execute(VirtualFrame frame) {
 
         final DynamicObject module = (DynamicObject) receiverObject;
 
-        ModuleNodes.getFields(module).setConstant(this, name, rhsValue);
+        Layouts.MODULE.getFields(module).setConstant(this, name, rhsValue);
 
         return rhsValue;
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/conversion/ToJavaStringNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/conversion/ToJavaStringNode.java
@@ -16,8 +16,8 @@
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyNode;
-import org.jruby.truffle.nodes.core.SymbolNodes;
 import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 @NodeChild(value="child", type=RubyNode.class)
 public abstract class ToJavaStringNode extends RubyNode {
@@ -33,7 +33,7 @@ public ToJavaStringNode(RubyContext context, SourceSection sourceSection) {
     @TruffleBoundary
     @Specialization(guards = "isRubySymbol(symbol)")
     protected String toJavaStringSymbol(DynamicObject symbol) {
-        return SymbolNodes.getString(symbol);
+        return Layouts.SYMBOL.getString(symbol);
     }
 
     @TruffleBoundary

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/conversion/ToSymbolNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/conversion/ToSymbolNode.java
@@ -15,8 +15,8 @@
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyNode;
-import org.jruby.truffle.nodes.core.StringNodes;
 import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 @NodeChild(value="child", type=RubyNode.class)
 public abstract class ToSymbolNode extends RubyNode {
@@ -36,7 +36,7 @@ protected DynamicObject toSymbolSymbol(DynamicObject symbol) {
 
     @Specialization(guards = "isRubyString(string)")
     protected DynamicObject toSymbolString(DynamicObject string) {
-        return getSymbol(StringNodes.getByteList(string));
+        return getSymbol(Layouts.STRING.getByteList(string));
     }
 
     @Specialization

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/BasicObjectNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/BasicObjectNodes.java
@@ -28,10 +28,10 @@
 import org.jruby.truffle.nodes.objects.AllocateObjectNode;
 import org.jruby.truffle.nodes.objects.AllocateObjectNodeGen;
 import org.jruby.truffle.nodes.yield.YieldDispatchHeadNode;
-import org.jruby.truffle.om.dsl.api.Nullable;
 import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
+import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.truffle.runtime.subsystems.ObjectSpaceManager;
 
 import java.util.LinkedHashMap;
@@ -45,27 +45,6 @@ public abstract class BasicObjectNodes {
     public static final HiddenKey TAINTED_IDENTIFIER = new HiddenKey("tainted?");
     public static final HiddenKey FROZEN_IDENTIFIER = new HiddenKey("frozen?");
 
-    @org.jruby.truffle.om.dsl.api.Layout(objectTypeSuperclass = "org.jruby.truffle.runtime.RubyObjectType")
-    public interface BasicObjectLayout {
-
-        DynamicObjectFactory createBasicObjectShape(@Nullable DynamicObject logicalClass, @Nullable DynamicObject metaClass);
-
-        DynamicObject createBasicObject(DynamicObjectFactory factory);
-
-        boolean isBasicObject(Object object);
-
-        DynamicObjectFactory setLogicalClass(DynamicObjectFactory factory, DynamicObject value);
-        DynamicObject getLogicalClass(ObjectType objectType);
-        DynamicObject getLogicalClass(DynamicObject object);
-        void setLogicalClass(DynamicObject object, DynamicObject value);
-
-        DynamicObjectFactory setMetaClass(DynamicObjectFactory factory, DynamicObject value);
-        DynamicObject getMetaClass(DynamicObject object);
-        void setMetaClass(DynamicObject object, DynamicObject value);
-    }
-
-    public static final BasicObjectLayout BASIC_OBJECT_LAYOUT = BasicObjectLayoutImpl.INSTANCE;
-
     @CompilerDirectives.TruffleBoundary
     public static void setInstanceVariable(DynamicObject receiver, Object name, Object value) {
         Shape shape = receiver.getShape();
@@ -117,14 +96,6 @@ public static boolean isFieldDefined(DynamicObject receiver, String name) {
         return receiver.getShape().hasProperty(name);
     }
 
-    public static DynamicObject getMetaClass(DynamicObject object) {
-        return BASIC_OBJECT_LAYOUT.getMetaClass(object);
-    }
-
-    public static void setMetaClass(DynamicObject object, DynamicObject metaClass) {
-        BASIC_OBJECT_LAYOUT.setMetaClass(object, metaClass);
-    }
-
     @CompilerDirectives.TruffleBoundary
     public static long verySlowGetObjectID(DynamicObject object) {
         // TODO(CS): we should specialise on reading this in the #object_id method and anywhere else it's used
@@ -151,7 +122,7 @@ public static Object getInstanceVariable(DynamicObject object, String name) {
 
     public static void visitObjectGraph(DynamicObject object, ObjectSpaceManager.ObjectGraphVisitor visitor) {
         if (visitor.visit(object)) {
-            visitObjectGraph(getMetaClass(object), visitor);
+            visitObjectGraph(Layouts.BASIC_OBJECT.getMetaClass(object), visitor);
 
             for (Object instanceVariable : getInstanceVariables(object).values()) {
                 if (instanceVariable instanceof DynamicObject) {
@@ -181,39 +152,39 @@ public static void visitObjectGraphChildren(DynamicObject rubyBasicObject, Objec
                 }
             }
         } else if (RubyGuards.isRubyBinding(rubyBasicObject)) {
-            getContext(rubyBasicObject).getObjectSpaceManager().visitFrame(BindingNodes.getFrame(rubyBasicObject), visitor);
+            getContext(rubyBasicObject).getObjectSpaceManager().visitFrame(Layouts.BINDING.getFrame(rubyBasicObject), visitor);
         } else if (RubyGuards.isRubyProc(rubyBasicObject)) {
-            getContext(rubyBasicObject).getObjectSpaceManager().visitFrame(ProcNodes.getDeclarationFrame(rubyBasicObject), visitor);
+            getContext(rubyBasicObject).getObjectSpaceManager().visitFrame(Layouts.PROC.getDeclarationFrame(rubyBasicObject), visitor);
         } else if (RubyGuards.isRubyMatchData(rubyBasicObject)) {
-            for (Object object : MatchDataNodes.getFields(rubyBasicObject).values) {
+            for (Object object : Layouts.MATCH_DATA.getFields(rubyBasicObject).values) {
                 if (object instanceof DynamicObject) {
                     visitObjectGraph(((DynamicObject) object), visitor);
                 }
             }
         } else if (RubyGuards.isObjectRange(rubyBasicObject)) {
-            if (RangeNodes.OBJECT_RANGE_LAYOUT.getBegin(rubyBasicObject) instanceof DynamicObject) {
-                visitObjectGraph(((DynamicObject) RangeNodes.OBJECT_RANGE_LAYOUT.getBegin(rubyBasicObject)), visitor);
+            if (Layouts.OBJECT_RANGE.getBegin(rubyBasicObject) instanceof DynamicObject) {
+                visitObjectGraph(((DynamicObject) Layouts.OBJECT_RANGE.getBegin(rubyBasicObject)), visitor);
             }
 
-            if (RangeNodes.OBJECT_RANGE_LAYOUT.getEnd(rubyBasicObject) instanceof DynamicObject) {
-                visitObjectGraph(((DynamicObject) RangeNodes.OBJECT_RANGE_LAYOUT.getEnd(rubyBasicObject)), visitor);
+            if (Layouts.OBJECT_RANGE.getEnd(rubyBasicObject) instanceof DynamicObject) {
+                visitObjectGraph(((DynamicObject) Layouts.OBJECT_RANGE.getEnd(rubyBasicObject)), visitor);
             }
         } else if (RubyGuards.isRubyModule(rubyBasicObject)) {
-            ModuleNodes.getFields(rubyBasicObject).visitObjectGraphChildren(visitor);
+            Layouts.MODULE.getFields(rubyBasicObject).visitObjectGraphChildren(visitor);
         }
     }
 
     @CompilerDirectives.TruffleBoundary
     public static RubyContext getContext(DynamicObject rubyBasicObject) {
         if (RubyGuards.isRubyModule(rubyBasicObject)) {
-            return ModuleNodes.getFields(rubyBasicObject).getContext();
+            return Layouts.MODULE.getFields(rubyBasicObject).getContext();
         } else {
             return getContext(getLogicalClass(rubyBasicObject));
         }
     }
 
     public static DynamicObject getLogicalClass(DynamicObject rubyBasicObject) {
-        return BASIC_OBJECT_LAYOUT.getLogicalClass(rubyBasicObject);
+        return Layouts.BASIC_OBJECT.getLogicalClass(rubyBasicObject);
     }
 
     @CoreMethod(names = "!")
@@ -321,7 +292,7 @@ public InstanceEvalNode(RubyContext context, SourceSection sourceSection) {
         @CompilerDirectives.TruffleBoundary
         @Specialization(guards = "isRubyString(string)")
         public Object instanceEval(Object receiver, DynamicObject string, NotProvided block) {
-            return getContext().instanceEval(StringNodes.getByteList(string), receiver, this);
+            return getContext().instanceEval(Layouts.STRING.getByteList(string), receiver, this);
         }
 
         @Specialization(guards = "isRubyProc(block)")
@@ -386,11 +357,11 @@ private Object methodMissing(Object self, DynamicObject name, Object[] args, Dyn
             if (lastCallWasVCall()) {
                 throw new RaiseException(
                         getContext().getCoreLibrary().nameErrorUndefinedLocalVariableOrMethod(
-                                SymbolNodes.getString(name),
-                                ModuleNodes.getFields(getContext().getCoreLibrary().getLogicalClass(self)).getName(),
+                                Layouts.SYMBOL.getString(name),
+                                Layouts.MODULE.getFields(getContext().getCoreLibrary().getLogicalClass(self)).getName(),
                                 this));
             } else {
-                throw new RaiseException(getContext().getCoreLibrary().noMethodErrorOnReceiver(SymbolNodes.getString(name), self, this));
+                throw new RaiseException(getContext().getCoreLibrary().noMethodErrorOnReceiver(Layouts.SYMBOL.getString(name), self, this));
             }
         }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/BignumNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/BignumNodes.java
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/BindingNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/BindingNodes.java
@@ -18,63 +18,29 @@
 import com.oracle.truffle.api.frame.FrameSlot;
 import com.oracle.truffle.api.frame.MaterializedFrame;
 import com.oracle.truffle.api.object.DynamicObject;
-import com.oracle.truffle.api.object.DynamicObjectFactory;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyGuards;
 import org.jruby.truffle.nodes.core.array.ArrayNodes;
 import org.jruby.truffle.nodes.locals.ReadFrameSlotNode;
 import org.jruby.truffle.nodes.locals.ReadFrameSlotNodeGen;
 import org.jruby.truffle.nodes.locals.WriteFrameSlotNode;
 import org.jruby.truffle.nodes.locals.WriteFrameSlotNodeGen;
-import org.jruby.truffle.om.dsl.api.Layout;
-import org.jruby.truffle.om.dsl.api.Nullable;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.ThreadLocalObject;
 import org.jruby.truffle.runtime.control.RaiseException;
+import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.truffle.runtime.methods.InternalMethod;
 
 @CoreClass(name = "Binding")
 public abstract class BindingNodes {
 
-    @Layout
-    public interface BindingLayout extends BasicObjectNodes.BasicObjectLayout {
-
-        DynamicObjectFactory createBindingShape(DynamicObject logicalClass, DynamicObject metaClass);
-
-        DynamicObject createBinding(DynamicObjectFactory factory, @Nullable Object self, @Nullable MaterializedFrame frame);
-
-        boolean isBinding(DynamicObject object);
-
-        Object getSelf(DynamicObject object);
-        void setSelf(DynamicObject object, Object self);
-
-        MaterializedFrame getFrame(DynamicObject object);
-        void setFrame(DynamicObject object, MaterializedFrame frame);
-
-    }
-
-    public static final BindingLayout BINDING_LAYOUT = BindingLayoutImpl.INSTANCE;
-
     public static DynamicObject createRubyBinding(DynamicObject bindingClass) {
         return createRubyBinding(bindingClass, null, null);
     }
 
     public static DynamicObject createRubyBinding(DynamicObject bindingClass, Object self, MaterializedFrame frame) {
-        return BINDING_LAYOUT.createBinding(ClassNodes.CLASS_LAYOUT.getInstanceFactory(bindingClass), self, frame);
-    }
-
-    public static void setSelfAndFrame(DynamicObject binding, Object self, MaterializedFrame frame) {
-        BINDING_LAYOUT.setSelf(binding, self);
-        BINDING_LAYOUT.setFrame(binding, frame);
-    }
-
-    public static Object getSelf(DynamicObject binding) {
-        return BINDING_LAYOUT.getSelf(binding);
-    }
-
-    public static MaterializedFrame getFrame(DynamicObject binding) {
-        return BINDING_LAYOUT.getFrame(binding);
+        return Layouts.BINDING.createBinding(Layouts.CLASS.getInstanceFactory(bindingClass), self, frame);
     }
 
     @CoreMethod(names = "initialize_copy", required = 1)
@@ -90,16 +56,17 @@ public Object initializeCopy(DynamicObject self, DynamicObject from) {
                 return self;
             }
 
-            final Object[] arguments = getFrame(from).getArguments();
+            final Object[] arguments = Layouts.BINDING.getFrame(from).getArguments();
             final InternalMethod method = RubyArguments.getMethod(arguments);
             final Object boundSelf = RubyArguments.getSelf(arguments);
             final DynamicObject boundBlock = RubyArguments.getBlock(arguments);
             final Object[] userArguments = RubyArguments.extractUserArguments(arguments);
 
-            final Object[] copiedArguments = RubyArguments.pack(method, getFrame(from), boundSelf, boundBlock, userArguments);
+            final Object[] copiedArguments = RubyArguments.pack(method, Layouts.BINDING.getFrame(from), boundSelf, boundBlock, userArguments);
             final MaterializedFrame copiedFrame = Truffle.getRuntime().createMaterializedFrame(copiedArguments);
 
-            setSelfAndFrame(self, getSelf(from), copiedFrame);
+            Layouts.BINDING.setSelf(self, Layouts.BINDING.getSelf(from));
+            Layouts.BINDING.setFrame(self, copiedFrame);
 
             return self;
         }
@@ -130,20 +97,20 @@ public Object localVariableGetCached(DynamicObject binding, DynamicObject symbol
                                              @Cached("createReadNode(cachedFrameSlot)") ReadFrameSlotNode readLocalVariableNode) {
             if (cachedFrameSlot == null) {
                 CompilerDirectives.transferToInterpreter();
-                throw new RaiseException(getContext().getCoreLibrary().nameErrorLocalVariableNotDefined(SymbolNodes.getString(symbol), binding, this));
+                throw new RaiseException(getContext().getCoreLibrary().nameErrorLocalVariableNotDefined(Layouts.SYMBOL.getString(symbol), binding, this));
             } else {
-                return readLocalVariableNode.executeRead(getFrame(binding));
+                return readLocalVariableNode.executeRead(Layouts.BINDING.getFrame(binding));
             }
         }
 
         @TruffleBoundary
         @Specialization(guards = {"isRubySymbol(symbol)", "!isLastLine(symbol)"})
         public Object localVariableGetUncached(DynamicObject binding, DynamicObject symbol) {
-            final MaterializedFrame frame = getFrame(binding);
-            final FrameSlot frameSlot = frame.getFrameDescriptor().findFrameSlot(SymbolNodes.getString(symbol));
+            final MaterializedFrame frame = Layouts.BINDING.getFrame(binding);
+            final FrameSlot frameSlot = frame.getFrameDescriptor().findFrameSlot(Layouts.SYMBOL.getString(symbol));
 
             if (frameSlot == null) {
-                throw new RaiseException(getContext().getCoreLibrary().nameErrorLocalVariableNotDefined(SymbolNodes.getString(symbol), binding, this));
+                throw new RaiseException(getContext().getCoreLibrary().nameErrorLocalVariableNotDefined(Layouts.SYMBOL.getString(symbol), binding, this));
             }
 
             return frame.getValue(frameSlot);
@@ -152,11 +119,11 @@ public Object localVariableGetUncached(DynamicObject binding, DynamicObject symb
         @TruffleBoundary
         @Specialization(guards = {"isRubySymbol(symbol)", "isLastLine(symbol)"})
         public Object localVariableGetLastLine(DynamicObject binding, DynamicObject symbol) {
-            final MaterializedFrame frame = getFrame(binding);
-            final FrameSlot frameSlot = frame.getFrameDescriptor().findFrameSlot(SymbolNodes.getString(symbol));
+            final MaterializedFrame frame = Layouts.BINDING.getFrame(binding);
+            final FrameSlot frameSlot = frame.getFrameDescriptor().findFrameSlot(Layouts.SYMBOL.getString(symbol));
 
             if (frameSlot == null) {
-                throw new RaiseException(getContext().getCoreLibrary().nameErrorLocalVariableNotDefined(SymbolNodes.getString(symbol), binding, this));
+                throw new RaiseException(getContext().getCoreLibrary().nameErrorLocalVariableNotDefined(Layouts.SYMBOL.getString(symbol), binding, this));
             }
 
             final Object value = frame.getValue(frameSlot);
@@ -169,16 +136,16 @@ public Object localVariableGetLastLine(DynamicObject binding, DynamicObject symb
 
         protected FrameDescriptor getFrameDescriptor(DynamicObject binding) {
             assert RubyGuards.isRubyBinding(binding);
-            return getFrame(binding).getFrameDescriptor();
+            return Layouts.BINDING.getFrame(binding).getFrameDescriptor();
         }
 
         protected FrameSlot findFrameSlot(DynamicObject binding, DynamicObject symbol) {
             assert RubyGuards.isRubyBinding(binding);
             assert RubyGuards.isRubySymbol(symbol);
 
-            final String symbolString = SymbolNodes.getString(symbol);
+            final String symbolString = Layouts.SYMBOL.getString(symbol);
 
-            MaterializedFrame frame = getFrame(binding);
+            MaterializedFrame frame = Layouts.BINDING.getFrame(binding);
 
             while (frame != null) {
                 final FrameSlot frameSlot = frame.getFrameDescriptor().findFrameSlot(symbolString);
@@ -227,39 +194,39 @@ public Object localVariableSetCached(DynamicObject binding, DynamicObject symbol
                                              @Cached("symbol") DynamicObject cachedSymbol,
                                              @Cached("getFrameDescriptor(binding)") FrameDescriptor cachedFrameDescriptor,
                                              @Cached("createWriteNode(findFrameSlot(binding, symbol))") WriteFrameSlotNode writeLocalVariableNode) {
-            return writeLocalVariableNode.executeWrite(getFrame(binding), value);
+            return writeLocalVariableNode.executeWrite(Layouts.BINDING.getFrame(binding), value);
         }
 
         @TruffleBoundary
         @Specialization(guards = {"isRubySymbol(symbol)", "!isLastLine(symbol)"})
         public Object localVariableSetUncached(DynamicObject binding, DynamicObject symbol, Object value) {
-            final MaterializedFrame frame = getFrame(binding);
-            final FrameSlot frameSlot = frame.getFrameDescriptor().findFrameSlot(SymbolNodes.getString(symbol));
+            final MaterializedFrame frame = Layouts.BINDING.getFrame(binding);
+            final FrameSlot frameSlot = frame.getFrameDescriptor().findFrameSlot(Layouts.SYMBOL.getString(symbol));
             frame.setObject(frameSlot, value);
             return value;
         }
 
         @TruffleBoundary
         @Specialization(guards = {"isRubySymbol(symbol)", "isLastLine(symbol)"})
         public Object localVariableSetLastLine(DynamicObject binding, DynamicObject symbol, Object value) {
-            final MaterializedFrame frame = getFrame(binding);
-            final FrameSlot frameSlot = frame.getFrameDescriptor().findFrameSlot(SymbolNodes.getString(symbol));
+            final MaterializedFrame frame = Layouts.BINDING.getFrame(binding);
+            final FrameSlot frameSlot = frame.getFrameDescriptor().findFrameSlot(Layouts.SYMBOL.getString(symbol));
             frame.setObject(frameSlot, ThreadLocalObject.wrap(getContext(), value));
             return value;
         }
 
         protected FrameDescriptor getFrameDescriptor(DynamicObject binding) {
             assert RubyGuards.isRubyBinding(binding);
-            return getFrame(binding).getFrameDescriptor();
+            return Layouts.BINDING.getFrame(binding).getFrameDescriptor();
         }
 
         protected FrameSlot findFrameSlot(DynamicObject binding, DynamicObject symbol) {
             assert RubyGuards.isRubyBinding(binding);
             assert RubyGuards.isRubySymbol(symbol);
 
-            final String symbolString = SymbolNodes.getString(symbol);
+            final String symbolString = Layouts.SYMBOL.getString(symbol);
 
-            MaterializedFrame frame = getFrame(binding);
+            MaterializedFrame frame = Layouts.BINDING.getFrame(binding);
 
             while (frame != null) {
                 final FrameSlot frameSlot = frame.getFrameDescriptor().findFrameSlot(symbolString);
@@ -271,7 +238,7 @@ protected FrameSlot findFrameSlot(DynamicObject binding, DynamicObject symbol) {
                 frame = RubyArguments.getDeclarationFrame(frame.getArguments());
             }
 
-            return getFrame(binding).getFrameDescriptor().addFrameSlot(symbolString);
+            return Layouts.BINDING.getFrame(binding).getFrameDescriptor().addFrameSlot(symbolString);
         }
 
         protected WriteFrameSlotNode createWriteNode(FrameSlot frameSlot) {
@@ -295,7 +262,7 @@ public LocalVariablesNode(RubyContext context, SourceSection sourceSection) {
         public DynamicObject localVariables(DynamicObject binding) {
             final DynamicObject array = createEmptyArray();
 
-            MaterializedFrame frame = getFrame(binding);
+            MaterializedFrame frame = Layouts.BINDING.getFrame(binding);
 
             while (frame != null) {
                 for (Object name : frame.getFrameDescriptor().getIdentifiers()) {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ClassNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ClassNodes.java
@@ -22,39 +22,14 @@
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.dispatch.CallDispatchHeadNode;
 import org.jruby.truffle.nodes.dispatch.DispatchHeadNodeFactory;
-import org.jruby.truffle.om.dsl.api.Layout;
-import org.jruby.truffle.om.dsl.api.Nullable;
 import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.core.ModuleFields;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 @CoreClass(name = "Class")
 public abstract class ClassNodes {
 
-    @Layout
-    public interface ClassLayout extends ModuleNodes.ModuleLayout {
-
-        DynamicObjectFactory createClassShape(DynamicObject logicalClass, DynamicObject metaClass);
-
-        DynamicObject createClass(DynamicObjectFactory factory,
-                                  ModuleFields model,
-                                  boolean isSingleton,
-                                  @Nullable DynamicObject attached,
-                                  @Nullable DynamicObjectFactory instanceFactory);
-
-        boolean isClass(DynamicObject object);
-
-        boolean getIsSingleton(DynamicObject object);
-
-        DynamicObject getAttached(DynamicObject object);
-
-        DynamicObjectFactory getInstanceFactory(DynamicObject object);
-        void setInstanceFactoryUnsafe(DynamicObject object, DynamicObjectFactory instanceFactory);
-
-    }
-
-    public static final ClassLayout CLASS_LAYOUT = ClassLayoutImpl.INSTANCE;
-
     /** Special constructor for class Class */
     public static DynamicObject createClassClass(RubyContext context) {
         final ModuleFields model = new ModuleFields(context, null, "Class");
@@ -63,20 +38,20 @@ public static DynamicObject createClassClass(RubyContext context) {
 
         final DynamicObject rubyClass = temporaryLayout.newInstance(temporaryLayout.createShape(new ObjectType()));
 
-        final DynamicObjectFactory factory = ClassNodes.CLASS_LAYOUT.createClassShape(rubyClass, rubyClass);
+        final DynamicObjectFactory factory = Layouts.CLASS.createClassShape(rubyClass, rubyClass);
 
         rubyClass.setShapeAndGrow(rubyClass.getShape(), factory.getShape());
         assert RubyGuards.isRubyModule(rubyClass);
         assert RubyGuards.isRubyClass(rubyClass);
 
         model.rubyModuleObject = rubyClass;
-        CLASS_LAYOUT.setInstanceFactoryUnsafe(rubyClass, factory);
-        ModuleNodes.MODULE_LAYOUT.setFields(rubyClass, model);
+        Layouts.CLASS.setInstanceFactoryUnsafe(rubyClass, factory);
+        Layouts.MODULE.setFields(rubyClass, model);
         model.name = model.givenBaseName;
 
         assert RubyGuards.isRubyModule(rubyClass);
         assert RubyGuards.isRubyClass(rubyClass);
-        assert ModuleNodes.getFields(rubyClass) == model;
+        assert Layouts.MODULE.getFields(rubyClass) == model;
         assert BasicObjectNodes.getLogicalClass(rubyClass) == rubyClass;
 
         return rubyClass;
@@ -91,26 +66,26 @@ public static DynamicObject createBootClass(DynamicObject classClass, DynamicObj
         assert superclass == null || RubyGuards.isRubyClass(superclass);
         final ModuleFields model = new ModuleFields(BasicObjectNodes.getContext(classClass), null, name);
 
-        final DynamicObject rubyClass = CLASS_LAYOUT.createClass(CLASS_LAYOUT.getInstanceFactory(classClass), model, false, null, null);
+        final DynamicObject rubyClass = Layouts.CLASS.createClass(Layouts.CLASS.getInstanceFactory(classClass), model, false, null, null);
         assert RubyGuards.isRubyClass(rubyClass) : classClass.getShape().getObjectType().getClass();
         assert RubyGuards.isRubyModule(rubyClass) : classClass.getShape().getObjectType().getClass();
 
         model.rubyModuleObject = rubyClass;
 
         if (model.lexicalParent == null) { // bootstrap or anonymous module
-            ModuleNodes.getFields(rubyClass).name = ModuleNodes.getFields(rubyClass).givenBaseName;
+            Layouts.MODULE.getFields(rubyClass).name = Layouts.MODULE.getFields(rubyClass).givenBaseName;
         } else {
-            ModuleNodes.getFields(rubyClass).getAdoptedByLexicalParent(model.lexicalParent, model.givenBaseName, null);
+            Layouts.MODULE.getFields(rubyClass).getAdoptedByLexicalParent(model.lexicalParent, model.givenBaseName, null);
         }
 
         if (superclass != null) {
             assert RubyGuards.isRubyClass(superclass);
-            assert RubyGuards.isRubyClass(ModuleNodes.getFields(rubyClass).rubyModuleObject);
+            assert RubyGuards.isRubyClass(Layouts.MODULE.getFields(rubyClass).rubyModuleObject);
 
-            ModuleNodes.getFields(rubyClass).parentModule = ModuleNodes.getFields(superclass).start;
-            ModuleNodes.getFields(superclass).addDependent(ModuleNodes.getFields(rubyClass).rubyModuleObject);
+            Layouts.MODULE.getFields(rubyClass).parentModule = Layouts.MODULE.getFields(superclass).start;
+            Layouts.MODULE.getFields(superclass).addDependent(Layouts.MODULE.getFields(rubyClass).rubyModuleObject);
 
-            ModuleNodes.getFields(rubyClass).newVersion();
+            Layouts.MODULE.getFields(rubyClass).newVersion();
         }
 
         return rubyClass;
@@ -134,32 +109,32 @@ public static DynamicObject createRubyClass(RubyContext context, DynamicObject l
     public static DynamicObject createRubyClass(RubyContext context, DynamicObject classClass, DynamicObject lexicalParent, DynamicObject superclass, String name, boolean isSingleton, DynamicObject attached) {
         final ModuleFields model = new ModuleFields(context, lexicalParent, name);
 
-        final DynamicObject rubyClass = CLASS_LAYOUT.createClass(CLASS_LAYOUT.getInstanceFactory(classClass), model, isSingleton, attached, null);
+        final DynamicObject rubyClass = Layouts.CLASS.createClass(Layouts.CLASS.getInstanceFactory(classClass), model, isSingleton, attached, null);
         assert RubyGuards.isRubyClass(rubyClass) : classClass.getShape().getObjectType().getClass();
         assert RubyGuards.isRubyModule(rubyClass) : classClass.getShape().getObjectType().getClass();
 
         model.rubyModuleObject = rubyClass;
 
         if (model.lexicalParent == null) { // bootstrap or anonymous module
-            ModuleNodes.getFields(rubyClass).name = ModuleNodes.getFields(rubyClass).givenBaseName;
+            Layouts.MODULE.getFields(rubyClass).name = Layouts.MODULE.getFields(rubyClass).givenBaseName;
         } else {
-            ModuleNodes.getFields(rubyClass).getAdoptedByLexicalParent(model.lexicalParent, model.givenBaseName, null);
+            Layouts.MODULE.getFields(rubyClass).getAdoptedByLexicalParent(model.lexicalParent, model.givenBaseName, null);
         }
 
         if (superclass != null) {
             assert RubyGuards.isRubyClass(superclass);
-            assert RubyGuards.isRubyClass(ModuleNodes.getFields(rubyClass).rubyModuleObject);
+            assert RubyGuards.isRubyClass(Layouts.MODULE.getFields(rubyClass).rubyModuleObject);
 
-            ModuleNodes.getFields(rubyClass).parentModule = ModuleNodes.getFields(superclass).start;
-            ModuleNodes.getFields(superclass).addDependent(ModuleNodes.getFields(rubyClass).rubyModuleObject);
+            Layouts.MODULE.getFields(rubyClass).parentModule = Layouts.MODULE.getFields(superclass).start;
+            Layouts.MODULE.getFields(superclass).addDependent(Layouts.MODULE.getFields(rubyClass).rubyModuleObject);
 
-            ModuleNodes.getFields(rubyClass).newVersion();
+            Layouts.MODULE.getFields(rubyClass).newVersion();
         }
 
-        DynamicObjectFactory factory = CLASS_LAYOUT.getInstanceFactory(superclass);
-        factory = BasicObjectNodes.BASIC_OBJECT_LAYOUT.setLogicalClass(factory, rubyClass);
-        factory = BasicObjectNodes.BASIC_OBJECT_LAYOUT.setMetaClass(factory, rubyClass);
-        CLASS_LAYOUT.setInstanceFactoryUnsafe(rubyClass, factory);
+        DynamicObjectFactory factory = Layouts.CLASS.getInstanceFactory(superclass);
+        factory = Layouts.BASIC_OBJECT.setLogicalClass(factory, rubyClass);
+        factory = Layouts.BASIC_OBJECT.setMetaClass(factory, rubyClass);
+        Layouts.CLASS.setInstanceFactoryUnsafe(rubyClass, factory);
 
         return rubyClass;
     }
@@ -168,16 +143,16 @@ public static DynamicObject createRubyClass(RubyContext context, DynamicObject c
     public static void initialize(DynamicObject rubyClass, DynamicObject superclass) {
         assert RubyGuards.isRubyClass(superclass);
 
-        ModuleNodes.getFields(rubyClass).parentModule = ModuleNodes.getFields(superclass).start;
-        ModuleNodes.getFields(superclass).addDependent(rubyClass);
+        Layouts.MODULE.getFields(rubyClass).parentModule = Layouts.MODULE.getFields(superclass).start;
+        Layouts.MODULE.getFields(superclass).addDependent(rubyClass);
 
-        ModuleNodes.getFields(rubyClass).newVersion();
+        Layouts.MODULE.getFields(rubyClass).newVersion();
         ensureSingletonConsistency(rubyClass);
 
-        DynamicObjectFactory factory = CLASS_LAYOUT.getInstanceFactory(superclass);
-        factory = BasicObjectNodes.BASIC_OBJECT_LAYOUT.setLogicalClass(factory, rubyClass);
-        factory = BasicObjectNodes.BASIC_OBJECT_LAYOUT.setMetaClass(factory, rubyClass);
-        CLASS_LAYOUT.setInstanceFactoryUnsafe(rubyClass, factory);
+        DynamicObjectFactory factory = Layouts.CLASS.getInstanceFactory(superclass);
+        factory = Layouts.BASIC_OBJECT.setLogicalClass(factory, rubyClass);
+        factory = Layouts.BASIC_OBJECT.setMetaClass(factory, rubyClass);
+        Layouts.CLASS.setInstanceFactoryUnsafe(rubyClass, factory);
     }
 
     public static DynamicObject ensureSingletonConsistency(DynamicObject rubyClass) {
@@ -194,8 +169,8 @@ public static DynamicObject getSingletonClass(DynamicObject rubyClass) {
     public static DynamicObject createOneSingletonClass(DynamicObject rubyClass) {
         CompilerAsserts.neverPartOfCompilation();
 
-        if (isSingleton(BasicObjectNodes.getMetaClass(rubyClass))) {
-            return BasicObjectNodes.getMetaClass(rubyClass);
+        if (Layouts.CLASS.getIsSingleton(Layouts.BASIC_OBJECT.getMetaClass(rubyClass))) {
+            return Layouts.BASIC_OBJECT.getMetaClass(rubyClass);
         }
 
         final DynamicObject singletonSuperclass;
@@ -205,25 +180,17 @@ public static DynamicObject createOneSingletonClass(DynamicObject rubyClass) {
             singletonSuperclass = createOneSingletonClass(getSuperClass(rubyClass));
         }
 
-        String name = String.format("#<Class:%s>", ModuleNodes.getFields(rubyClass).getName());
-        BasicObjectNodes.setMetaClass(rubyClass, ClassNodes.createRubyClass(BasicObjectNodes.getContext(rubyClass), BasicObjectNodes.getLogicalClass(rubyClass), null, singletonSuperclass, name, true, rubyClass));
+        String name = String.format("#<Class:%s>", Layouts.MODULE.getFields(rubyClass).getName());
+        Layouts.BASIC_OBJECT.setMetaClass(rubyClass, ClassNodes.createRubyClass(BasicObjectNodes.getContext(rubyClass), BasicObjectNodes.getLogicalClass(rubyClass), null, singletonSuperclass, name, true, rubyClass));
 
-        return BasicObjectNodes.getMetaClass(rubyClass);
+        return Layouts.BASIC_OBJECT.getMetaClass(rubyClass);
     }
 
 
-    public static boolean isSingleton(DynamicObject rubyClass) {
-        return CLASS_LAYOUT.getIsSingleton(rubyClass);
-    }
-
-    public static DynamicObject getAttached(DynamicObject rubyClass) {
-        return CLASS_LAYOUT.getAttached(rubyClass);
-    }
-
     public static DynamicObject getSuperClass(DynamicObject rubyClass) {
         CompilerAsserts.neverPartOfCompilation();
 
-        for (DynamicObject ancestor : ModuleNodes.getFields(rubyClass).parentAncestors()) {
+        for (DynamicObject ancestor : Layouts.MODULE.getFields(rubyClass).parentAncestors()) {
             if (RubyGuards.isRubyClass(ancestor)) {
                 return ancestor;
             }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/CoreMethodNodeManager.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/CoreMethodNodeManager.java
@@ -30,6 +30,7 @@
 import org.jruby.truffle.runtime.*;
 import org.jruby.truffle.runtime.array.ArrayUtils;
 import org.jruby.truffle.runtime.core.CoreSourceSection;
+import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.truffle.runtime.methods.Arity;
 import org.jruby.truffle.runtime.methods.InternalMethod;
 import org.jruby.truffle.runtime.methods.SharedMethodInfo;
@@ -108,7 +109,7 @@ private void addCoreMethod(MethodDetails methodDetails) {
             if (method.constructor()) {
                 System.err.println("WARNING: Either constructor or isModuleFunction for " + methodDetails.getIndicativeName());
             }
-            if (!(RubyGuards.isRubyModule(ModuleNodes.getFields(module).rubyModuleObject) && !RubyGuards.isRubyClass(ModuleNodes.getFields(module).rubyModuleObject))) {
+            if (!(RubyGuards.isRubyModule(Layouts.MODULE.getFields(module).rubyModuleObject) && !RubyGuards.isRubyClass(Layouts.MODULE.getFields(module).rubyModuleObject))) {
                 System.err.println("WARNING: Using isModuleFunction on a Class for " + methodDetails.getIndicativeName());
             }
         }
@@ -142,7 +143,7 @@ private static void addMethod(DynamicObject module, RubyRootNode rootNode, List<
             final InternalMethod method = new InternalMethod(rootNodeCopy.getSharedMethodInfo(), name, module, visibility, false,
                     Truffle.getRuntime().createCallTarget(rootNodeCopy), null);
 
-            ModuleNodes.getFields(module).addMethod(null, method.withVisibility(visibility).withName(name));
+            Layouts.MODULE.getFields(module).addMethod(null, method.withVisibility(visibility).withName(name));
         }
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/EncodingConverterNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/EncodingConverterNodes.java
@@ -13,7 +13,6 @@
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.object.DynamicObject;
-import com.oracle.truffle.api.object.DynamicObjectFactory;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jcodings.Encoding;
 import org.jcodings.EncodingDB;
@@ -27,41 +26,16 @@
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.truffle.nodes.dispatch.CallDispatchHeadNode;
 import org.jruby.truffle.nodes.dispatch.DispatchHeadNodeFactory;
-import org.jruby.truffle.om.dsl.api.Layout;
-import org.jruby.truffle.om.dsl.api.Nullable;
 import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.util.ByteList;
 import org.jruby.util.io.EncodingUtils;
 
 @CoreClass(name = "Encoding::Converter")
 public abstract class EncodingConverterNodes {
 
-    @Layout
-    public interface EncodingConverterLayout extends BasicObjectNodes.BasicObjectLayout {
-
-        DynamicObjectFactory createEncodingConverterShape(DynamicObject logicalClass, DynamicObject metaClass);
-
-        DynamicObject createEncodingConverter(DynamicObjectFactory factory, @Nullable EConv econv);
-
-        boolean isEncodingConverter(DynamicObject object);
-
-        EConv getEconv(DynamicObject object);
-        void setEconv(DynamicObject object, EConv econv);
-
-    }
-
-    public static final EncodingConverterLayout ENCODING_CONVERTER_LAYOUT = EncodingConverterLayoutImpl.INSTANCE;
-
-    public static EConv getEConv(DynamicObject encodingConverter) {
-        return ENCODING_CONVERTER_LAYOUT.getEconv(encodingConverter);
-    }
-
-    public static void setEConv(DynamicObject encodingConverter, EConv econv) {
-        ENCODING_CONVERTER_LAYOUT.setEconv(encodingConverter, econv);
-    }
-
     public static DynamicObject createEncodingConverter(DynamicObject rubyClass, EConv econv) {
-        return ENCODING_CONVERTER_LAYOUT.createEncodingConverter(ClassNodes.CLASS_LAYOUT.getInstanceFactory(rubyClass), econv);
+        return Layouts.ENCODING_CONVERTER.createEncodingConverter(Layouts.CLASS.getInstanceFactory(rubyClass), econv);
     }
 
     @RubiniusOnly
@@ -112,7 +86,7 @@ public DynamicObject initialize(DynamicObject self, Object source, Object destin
             econv.sourceEncoding = encs[0];
             econv.destinationEncoding = encs[1];
 
-            setEConv(self, econv);
+            Layouts.ENCODING_CONVERTER.setEconv(self, econv);
 
             return nil();
         }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/EncodingNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/EncodingNodes.java
@@ -14,7 +14,6 @@
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.object.DynamicObject;
-import com.oracle.truffle.api.object.DynamicObjectFactory;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jcodings.Encoding;
 import org.jcodings.EncodingDB;
@@ -26,9 +25,9 @@
 import org.jruby.truffle.nodes.coerce.ToStrNodeGen;
 import org.jruby.truffle.nodes.dispatch.CallDispatchHeadNode;
 import org.jruby.truffle.nodes.dispatch.DispatchHeadNodeFactory;
-import org.jruby.truffle.om.dsl.api.Layout;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
+import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.util.ByteList;
 
 import java.nio.charset.StandardCharsets;
@@ -39,25 +38,6 @@
 @CoreClass(name = "Encoding")
 public abstract class EncodingNodes {
 
-    @Layout
-    public interface EncodingLayout extends BasicObjectNodes.BasicObjectLayout {
-
-        DynamicObjectFactory createEncodingShape(DynamicObject logicalClass, DynamicObject metaClass);
-
-        DynamicObject createEncoding(DynamicObjectFactory factory, Encoding encoding, ByteList name, boolean dummy);
-
-        boolean isEncoding(DynamicObject object);
-
-        Encoding getEncoding(DynamicObject object);
-
-        ByteList getName(DynamicObject object);
-
-        boolean getDummy(DynamicObject object);
-
-    }
-
-    public static final EncodingLayout ENCODING_LAYOUT = EncodingLayoutImpl.INSTANCE;
-
     // Both are mutated only in CoreLibrary.initializeEncodingConstants().
     private static DynamicObject[] encodingList = new DynamicObject[EncodingDB.getEncodings().size()];
     private static Map<String, DynamicObject> lookup = new HashMap<>();
@@ -80,7 +60,7 @@ public static DynamicObject getEncoding(int index) {
     public static void storeEncoding(int encodingListIndex, DynamicObject encoding) {
         assert RubyGuards.isRubyEncoding(encoding);
         encodingList[encodingListIndex] = encoding;
-        lookup.put(getName(encoding).toString().toLowerCase(Locale.ENGLISH), encoding);
+        lookup.put(Layouts.ENCODING.getName(encoding).toString().toLowerCase(Locale.ENGLISH), encoding);
     }
 
     @TruffleBoundary
@@ -93,18 +73,6 @@ public static DynamicObject newEncoding(DynamicObject encodingClass, Encoding en
         return createRubyEncoding(encodingClass, encoding, new ByteList(name, p, end), dummy);
     }
 
-    public static Encoding getEncoding(DynamicObject encoding) {
-        return ENCODING_LAYOUT.getEncoding(encoding);
-    }
-
-    public static ByteList getName(DynamicObject encoding) {
-        return ENCODING_LAYOUT.getName(encoding);
-    }
-
-    public static boolean isDummy(DynamicObject encoding) {
-        return ENCODING_LAYOUT.getDummy(encoding);
-    }
-
     public static DynamicObject[] cloneEncodingList() {
         final DynamicObject[] clone = new DynamicObject[encodingList.length];
 
@@ -114,7 +82,7 @@ public static DynamicObject[] cloneEncodingList() {
     }
 
     public static DynamicObject createRubyEncoding(DynamicObject encodingClass, Encoding encoding, ByteList name, boolean dummy) {
-        return ENCODING_LAYOUT.createEncoding(ClassNodes.CLASS_LAYOUT.getInstanceFactory(encodingClass), encoding, name, dummy);
+        return Layouts.ENCODING.createEncoding(Layouts.CLASS.getInstanceFactory(encodingClass), encoding, name, dummy);
     }
 
     @CoreMethod(names = "ascii_compatible?")
@@ -127,7 +95,7 @@ public AsciiCompatibleNode(RubyContext context, SourceSection sourceSection) {
         @Specialization
         public Object isCompatible(DynamicObject encoding) {
             CompilerDirectives.transferToInterpreter();
-            return getEncoding(encoding).isAsciiCompatible();
+            return Layouts.ENCODING.getEncoding(encoding).isAsciiCompatible();
         }
     }
 
@@ -153,7 +121,7 @@ public Object isCompatibleStringString(DynamicObject first, DynamicObject second
         @TruffleBoundary
         @Specialization(guards = {"isRubyEncoding(first)", "isRubyEncoding(second)"})
         public Object isCompatibleEncodingEncoding(DynamicObject first, DynamicObject second) {
-            final Encoding compatibleEncoding = org.jruby.RubyEncoding.areCompatible(getEncoding(first), getEncoding(second));
+            final Encoding compatibleEncoding = org.jruby.RubyEncoding.areCompatible(Layouts.ENCODING.getEncoding(first), Layouts.ENCODING.getEncoding(second));
 
             if (compatibleEncoding != null) {
                 return getEncoding(compatibleEncoding);
@@ -165,7 +133,7 @@ public Object isCompatibleEncodingEncoding(DynamicObject first, DynamicObject se
         @TruffleBoundary
         @Specialization(guards = {"isRubyString(first)", "isRubyRegexp(second)"})
         public Object isCompatibleStringRegexp(DynamicObject first, DynamicObject second) {
-            final Encoding compatibleEncoding = org.jruby.RubyEncoding.areCompatible(StringNodes.getByteList(first).getEncoding(), RegexpNodes.getRegex(second).getEncoding());
+            final Encoding compatibleEncoding = org.jruby.RubyEncoding.areCompatible(Layouts.STRING.getByteList(first).getEncoding(), Layouts.REGEXP.getRegex(second).getEncoding());
 
             if (compatibleEncoding != null) {
                 return getEncoding(compatibleEncoding);
@@ -177,7 +145,7 @@ public Object isCompatibleStringRegexp(DynamicObject first, DynamicObject second
         @TruffleBoundary
         @Specialization(guards = {"isRubyRegexp(first)", "isRubyString(second)"})
         public Object isCompatibleRegexpString(DynamicObject first, DynamicObject second) {
-            final Encoding compatibleEncoding = org.jruby.RubyEncoding.areCompatible(RegexpNodes.getRegex(first).getEncoding(), StringNodes.getByteList(second).getEncoding());
+            final Encoding compatibleEncoding = org.jruby.RubyEncoding.areCompatible(Layouts.REGEXP.getRegex(first).getEncoding(), Layouts.STRING.getByteList(second).getEncoding());
 
             if (compatibleEncoding != null) {
                 return getEncoding(compatibleEncoding);
@@ -189,7 +157,7 @@ public Object isCompatibleRegexpString(DynamicObject first, DynamicObject second
         @TruffleBoundary
         @Specialization(guards = {"isRubyRegexp(first)", "isRubyRegexp(second)"})
         public Object isCompatibleRegexpRegexp(DynamicObject first, DynamicObject second) {
-            final Encoding compatibleEncoding = org.jruby.RubyEncoding.areCompatible(RegexpNodes.getRegex(first).getEncoding(), RegexpNodes.getRegex(second).getEncoding());
+            final Encoding compatibleEncoding = org.jruby.RubyEncoding.areCompatible(Layouts.REGEXP.getRegex(first).getEncoding(), Layouts.REGEXP.getRegex(second).getEncoding());
 
             if (compatibleEncoding != null) {
                 return getEncoding(compatibleEncoding);
@@ -201,7 +169,7 @@ public Object isCompatibleRegexpRegexp(DynamicObject first, DynamicObject second
         @TruffleBoundary
         @Specialization(guards = {"isRubyRegexp(first)", "isRubySymbol(second)"})
         public Object isCompatibleRegexpSymbol(DynamicObject first, DynamicObject second) {
-            final Encoding compatibleEncoding = org.jruby.RubyEncoding.areCompatible(RegexpNodes.getRegex(first).getEncoding(), SymbolNodes.getByteList(second).getEncoding());
+            final Encoding compatibleEncoding = org.jruby.RubyEncoding.areCompatible(Layouts.REGEXP.getRegex(first).getEncoding(), Layouts.SYMBOL.getByteList(second).getEncoding());
 
             if (compatibleEncoding != null) {
                 return getEncoding(compatibleEncoding);
@@ -213,7 +181,7 @@ public Object isCompatibleRegexpSymbol(DynamicObject first, DynamicObject second
         @TruffleBoundary
         @Specialization(guards = {"isRubySymbol(first)", "isRubyRegexp(second)"})
         public Object isCompatibleSymbolRegexp(DynamicObject first, DynamicObject second) {
-            final Encoding compatibleEncoding = org.jruby.RubyEncoding.areCompatible(SymbolNodes.getByteList(first).getEncoding(), RegexpNodes.getRegex(second).getEncoding());
+            final Encoding compatibleEncoding = org.jruby.RubyEncoding.areCompatible(Layouts.SYMBOL.getByteList(first).getEncoding(), Layouts.REGEXP.getRegex(second).getEncoding());
 
             if (compatibleEncoding != null) {
                 return getEncoding(compatibleEncoding);
@@ -249,7 +217,7 @@ public Object isCompatibleSymbolSymbol(DynamicObject first, DynamicObject second
         @TruffleBoundary
         @Specialization(guards = {"isRubyString(first)", "isRubyEncoding(second)"})
         public Object isCompatibleStringEncoding(DynamicObject first, DynamicObject second) {
-            final Encoding compatibleEncoding = org.jruby.RubyEncoding.areCompatible(StringNodes.getByteList(first).getEncoding(), getEncoding(second));
+            final Encoding compatibleEncoding = org.jruby.RubyEncoding.areCompatible(Layouts.STRING.getByteList(first).getEncoding(), Layouts.ENCODING.getEncoding(second));
 
             if (compatibleEncoding != null) {
                 return getEncoding(compatibleEncoding);
@@ -274,7 +242,7 @@ public SetDefaultExternalNode(RubyContext context, SourceSection sourceSection)
         public DynamicObject defaultExternalEncoding(DynamicObject encoding) {
             CompilerDirectives.transferToInterpreter();
 
-            getContext().getRuntime().setDefaultExternalEncoding(getEncoding(encoding));
+            getContext().getRuntime().setDefaultExternalEncoding(Layouts.ENCODING.getEncoding(encoding));
 
             return encoding;
         }
@@ -284,7 +252,7 @@ public DynamicObject defaultExternal(DynamicObject encodingString) {
             CompilerDirectives.transferToInterpreter();
 
             final DynamicObject rubyEncoding = getEncoding(encodingString.toString());
-            getContext().getRuntime().setDefaultExternalEncoding(getEncoding(rubyEncoding));
+            getContext().getRuntime().setDefaultExternalEncoding(Layouts.ENCODING.getEncoding(rubyEncoding));
 
             return rubyEncoding;
         }
@@ -320,7 +288,7 @@ public SetDefaultInternalNode(RubyContext context, SourceSection sourceSection)
         public DynamicObject defaultInternal(DynamicObject encoding) {
             CompilerDirectives.transferToInterpreter();
 
-            getContext().getRuntime().setDefaultInternalEncoding(getEncoding(encoding));
+            getContext().getRuntime().setDefaultInternalEncoding(Layouts.ENCODING.getEncoding(encoding));
 
             return encoding;
         }
@@ -344,7 +312,7 @@ public DynamicObject defaultInternal(VirtualFrame frame, Object encoding) {
             }
 
             final DynamicObject encodingName = toStrNode.executeToStr(frame, encoding);
-            getContext().getRuntime().setDefaultInternalEncoding(getEncoding(getEncoding(encodingName.toString())));
+            getContext().getRuntime().setDefaultInternalEncoding(Layouts.ENCODING.getEncoding(getEncoding(encodingName.toString())));
 
             return encodingName;
         }
@@ -393,7 +361,7 @@ public DummyNode(RubyContext context, SourceSection sourceSection) {
 
         @Specialization
         public boolean isDummy(DynamicObject encoding) {
-            return EncodingNodes.isDummy(encoding);
+            return Layouts.ENCODING.getDummy(encoding);
         }
     }
 
@@ -422,7 +390,7 @@ public Object encodingMap(VirtualFrame frame) {
 
             final DynamicObject[] encodings = cloneEncodingList();
             for (int i = 0; i < encodings.length; i++) {
-                final Object upcased = upcaseNode.call(frame, createString(getName(encodings[i])), "upcase", null);
+                final Object upcased = upcaseNode.call(frame, createString(Layouts.ENCODING.getName(encodings[i])), "upcase", null);
                 final Object key = toSymNode.call(frame, upcased, "to_sym", null);
                 final Object value = newTupleNode.call(frame, getContext().getCoreLibrary().getTupleClass(), "create", null, nil(), i);
 
@@ -476,7 +444,7 @@ public Object indexLookup(DynamicObject[] encodings, Encoding encoding) {
             }
 
             for (int i = 0; i < encodings.length; i++) {
-                if (getEncoding(encodings[i]) == encoding) {
+                if (Layouts.ENCODING.getEncoding(encodings[i]) == encoding) {
                     return i;
                 }
             }
@@ -495,7 +463,7 @@ public ToSNode(RubyContext context, SourceSection sourceSection) {
         @TruffleBoundary
         @Specialization
         public DynamicObject toS(DynamicObject encoding) {
-            final ByteList name = getName(encoding).dup();
+            final ByteList name = Layouts.ENCODING.getName(encoding).dup();
             name.setEncoding(ASCIIEncoding.INSTANCE);
             return createString(name);
         }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ExceptionNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ExceptionNodes.java
@@ -12,44 +12,23 @@
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.object.DynamicObject;
-import com.oracle.truffle.api.object.DynamicObjectFactory;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyGuards;
 import org.jruby.truffle.nodes.core.array.ArrayNodes;
 import org.jruby.truffle.nodes.objectstorage.ReadHeadObjectFieldNode;
-import org.jruby.truffle.om.dsl.api.Layout;
-import org.jruby.truffle.om.dsl.api.Nullable;
 import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.RubyCallStack;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.backtrace.Activation;
 import org.jruby.truffle.runtime.backtrace.Backtrace;
 import org.jruby.truffle.runtime.backtrace.MRIBacktraceFormatter;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 import java.util.List;
 
 @CoreClass(name = "Exception")
 public abstract class ExceptionNodes {
 
-    @Layout
-    public interface ExceptionLayout extends BasicObjectNodes.BasicObjectLayout {
-
-        DynamicObjectFactory createExceptionShape(DynamicObject logicalClass, DynamicObject metaClass);
-
-        DynamicObject createException(DynamicObjectFactory factory, @Nullable Object message, @Nullable Backtrace backtrace);
-
-        boolean isException(DynamicObject object);
-
-        Object getMessage(DynamicObject object);
-        void setMessage(DynamicObject object, Object message);
-
-        Backtrace getBacktrace(DynamicObject object);
-        void setBacktrace(DynamicObject object, Backtrace backtrace);
-
-    }
-
-    public static final ExceptionLayout EXCEPTION_LAYOUT = ExceptionLayoutImpl.INSTANCE;
-
     public static class BacktraceFormatter extends MRIBacktraceFormatter {
         @Override
         protected String formatFromLine(List<Activation> activations, int n) {
@@ -59,25 +38,12 @@ protected String formatFromLine(List<Activation> activations, int n) {
 
     public static final BacktraceFormatter BACKTRACE_FORMATTER = new BacktraceFormatter();
 
-    // TODO (eregon 16 Apr. 2015): MRI does a dynamic calls to "message"
-    public static Object getMessage(DynamicObject exception) {
-        return EXCEPTION_LAYOUT.getMessage(exception);
-    }
-
-    public static Backtrace getBacktrace(DynamicObject exception) {
-        return EXCEPTION_LAYOUT.getBacktrace(exception);
-    }
-
-    public static void setBacktrace(DynamicObject exception, Backtrace backtrace) {
-        EXCEPTION_LAYOUT.setBacktrace(exception, backtrace);
-    }
-
     @TruffleBoundary
     public static DynamicObject asRubyStringArray(DynamicObject exception) {
         assert RubyGuards.isRubyException(exception);
 
-        assert getBacktrace(exception) != null;
-        final String[] lines = BACKTRACE_FORMATTER.format(BasicObjectNodes.getContext(exception), exception, getBacktrace(exception));
+        assert Layouts.EXCEPTION.getBacktrace(exception) != null;
+        final String[] lines = BACKTRACE_FORMATTER.format(BasicObjectNodes.getContext(exception), exception, Layouts.EXCEPTION.getBacktrace(exception));
 
         final Object[] array = new Object[lines.length];
 
@@ -89,15 +55,15 @@ public static DynamicObject asRubyStringArray(DynamicObject exception) {
     }
 
     public static void setMessage(DynamicObject exception, Object message) {
-        EXCEPTION_LAYOUT.setMessage(exception, message);
+        Layouts.EXCEPTION.setMessage(exception, message);
     }
 
     public static DynamicObject createRubyException(DynamicObject rubyClass) {
-        return EXCEPTION_LAYOUT.createException(ClassNodes.CLASS_LAYOUT.getInstanceFactory(rubyClass), null, null);
+        return Layouts.EXCEPTION.createException(Layouts.CLASS.getInstanceFactory(rubyClass), null, null);
     }
 
     public static DynamicObject createRubyException(DynamicObject rubyClass, Object message, Backtrace backtrace) {
-        return EXCEPTION_LAYOUT.createException(ClassNodes.CLASS_LAYOUT.getInstanceFactory(rubyClass), message, backtrace);
+        return Layouts.EXCEPTION.createException(Layouts.CLASS.getInstanceFactory(rubyClass), message, backtrace);
     }
 
     @CoreMethod(names = "initialize", optional = 1)
@@ -135,7 +101,7 @@ public BacktraceNode(RubyContext context, SourceSection sourceSection) {
         public Object backtrace(DynamicObject exception) {
             if (readCustomBacktrace.isSet(exception)) {
                 return readCustomBacktrace.execute(exception);
-            } else if (getBacktrace(exception) != null) {
+            } else if (Layouts.EXCEPTION.getBacktrace(exception) != null) {
                 return asRubyStringArray(exception);
             } else {
                 return nil();
@@ -160,7 +126,7 @@ public DynamicObject captureBacktrace(DynamicObject exception, NotProvided offse
         @Specialization
         public DynamicObject captureBacktrace(DynamicObject exception, int offset) {
             Backtrace backtrace = RubyCallStack.getBacktrace(this, offset);
-            setBacktrace(exception, backtrace);
+            Layouts.EXCEPTION.setBacktrace(exception, backtrace);
             return nil();
         }
 
@@ -175,7 +141,7 @@ public MessageNode(RubyContext context, SourceSection sourceSection) {
 
         @Specialization
         public Object message(DynamicObject exception) {
-            return getMessage(exception);
+            return Layouts.EXCEPTION.getMessage(exception);
         }
 
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/FiberNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/FiberNodes.java
@@ -14,18 +14,17 @@
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.nodes.ControlFlowException;
 import com.oracle.truffle.api.object.DynamicObject;
-import com.oracle.truffle.api.object.DynamicObjectFactory;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyGuards;
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.cast.SingleValueCastNode;
 import org.jruby.truffle.nodes.cast.SingleValueCastNodeGen;
 import org.jruby.truffle.nodes.core.FiberNodesFactory.FiberTransferNodeFactory;
 import org.jruby.truffle.nodes.methods.UnsupportedOperationBehavior;
-import org.jruby.truffle.om.dsl.api.Layout;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.control.ReturnException;
+import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.truffle.runtime.subsystems.FiberManager;
 import org.jruby.truffle.runtime.subsystems.ThreadManager;
 
@@ -35,25 +34,6 @@
 @CoreClass(name = "Fiber")
 public abstract class FiberNodes {
 
-    @Layout
-    public interface FiberLayout extends BasicObjectNodes.BasicObjectLayout {
-
-        DynamicObjectFactory createFiberShape(DynamicObject logicalClass, DynamicObject metaClass);
-
-        DynamicObject createFiber(DynamicObjectFactory factory, FiberFields fields);
-
-        boolean isFiber(DynamicObject object);
-
-        FiberFields getFields(DynamicObject object);
-
-    }
-
-    public static final FiberLayout FIBER_LAYOUT = FiberLayoutImpl.INSTANCE;
-
-    public static FiberFields getFields(DynamicObject fiber) {
-        return FIBER_LAYOUT.getFields(fiber);
-    }
-
     public static DynamicObject newRootFiber(DynamicObject thread, FiberManager fiberManager, ThreadManager threadManager) {
         assert RubyGuards.isRubyThread(thread);
         RubyContext context = BasicObjectNodes.getContext(thread);
@@ -63,14 +43,14 @@ public static DynamicObject newRootFiber(DynamicObject thread, FiberManager fibe
     public static void initialize(final DynamicObject fiber, final DynamicObject block) {
         assert RubyGuards.isRubyFiber(fiber);
         assert RubyGuards.isRubyProc(block);
-        getFields(fiber).name = "Ruby Fiber@" + ProcNodes.getSharedMethodInfo(block).getSourceSection().getShortDescription();
+        Layouts.FIBER.getFields(fiber).name = "Ruby Fiber@" + Layouts.PROC.getSharedMethodInfo(block).getSourceSection().getShortDescription();
         final Thread thread = new Thread(new Runnable() {
             @Override
             public void run() {
                 handleFiberExceptions(fiber, block);
             }
         });
-        thread.setName(getFields(fiber).name);
+        thread.setName(Layouts.FIBER.getFields(fiber).name);
         thread.start();
     }
 
@@ -88,16 +68,16 @@ public void run() {
                         result = ProcNodes.rootCall(block, args);
                     } finally {
                         // Make sure that other fibers notice we are dead before they gain control back
-                        getFields(fiber).alive = false;
+                        Layouts.FIBER.getFields(fiber).alive = false;
                     }
-                    resume(fiber, getFields(fiber).lastResumedByFiber, true, result);
+                    resume(fiber, Layouts.FIBER.getFields(fiber).lastResumedByFiber, true, result);
                 } catch (FiberExitException e) {
-                    assert !getFields(fiber).isRootFiber;
+                    assert !Layouts.FIBER.getFields(fiber).isRootFiber;
                     // Naturally exit the Java thread on catching this
                 } catch (ReturnException e) {
-                    sendMessageTo(getFields(fiber).lastResumedByFiber, new FiberExceptionMessage(BasicObjectNodes.getContext(fiber).getCoreLibrary().unexpectedReturn(null)));
+                    sendMessageTo(Layouts.FIBER.getFields(fiber).lastResumedByFiber, new FiberExceptionMessage(BasicObjectNodes.getContext(fiber).getCoreLibrary().unexpectedReturn(null)));
                 } catch (RaiseException e) {
-                    sendMessageTo(getFields(fiber).lastResumedByFiber, new FiberExceptionMessage((DynamicObject) e.getRubyException()));
+                    sendMessageTo(Layouts.FIBER.getFields(fiber).lastResumedByFiber, new FiberExceptionMessage((DynamicObject) e.getRubyException()));
                 }
             }
         });
@@ -117,24 +97,24 @@ public static void run(DynamicObject fiber, final Runnable task) {
     // Only used by the main thread which cannot easily wrap everything inside a try/finally.
     public static void start(DynamicObject fiber) {
         assert RubyGuards.isRubyFiber(fiber);
-        getFields(fiber).thread = Thread.currentThread();
-        BasicObjectNodes.getContext(fiber).getThreadManager().initializeCurrentThread(getFields(fiber).rubyThread);
-        ThreadNodes.getFiberManager(getFields(fiber).rubyThread).registerFiber(fiber);
+        Layouts.FIBER.getFields(fiber).thread = Thread.currentThread();
+        BasicObjectNodes.getContext(fiber).getThreadManager().initializeCurrentThread(Layouts.FIBER.getFields(fiber).rubyThread);
+        ThreadNodes.getFiberManager(Layouts.FIBER.getFields(fiber).rubyThread).registerFiber(fiber);
         BasicObjectNodes.getContext(fiber).getSafepointManager().enterThread();
     }
 
     // Only used by the main thread which cannot easily wrap everything inside a try/finally.
     public static void cleanup(DynamicObject fiber) {
         assert RubyGuards.isRubyFiber(fiber);
-        getFields(fiber).alive = false;
+        Layouts.FIBER.getFields(fiber).alive = false;
         BasicObjectNodes.getContext(fiber).getSafepointManager().leaveThread();
-        ThreadNodes.getFiberManager(getFields(fiber).rubyThread).unregisterFiber(fiber);
-        getFields(fiber).thread = null;
+        ThreadNodes.getFiberManager(Layouts.FIBER.getFields(fiber).rubyThread).unregisterFiber(fiber);
+        Layouts.FIBER.getFields(fiber).thread = null;
     }
 
     private static void sendMessageTo(DynamicObject fiber, FiberMessage message) {
         assert RubyGuards.isRubyFiber(fiber);
-        getFields(fiber).messageQueue.add(message);
+        Layouts.FIBER.getFields(fiber).messageQueue.add(message);
     }
 
     /**
@@ -148,21 +128,21 @@ private static Object[] waitForResume(final DynamicObject fiber) {
         final FiberMessage message = BasicObjectNodes.getContext(fiber).getThreadManager().runUntilResult(new ThreadManager.BlockingAction<FiberMessage>() {
             @Override
             public FiberMessage block() throws InterruptedException {
-                return getFields(fiber).messageQueue.take();
+                return Layouts.FIBER.getFields(fiber).messageQueue.take();
             }
         });
 
-        ThreadNodes.getFiberManager(getFields(fiber).rubyThread).setCurrentFiber(fiber);
+        ThreadNodes.getFiberManager(Layouts.FIBER.getFields(fiber).rubyThread).setCurrentFiber(fiber);
 
         if (message instanceof FiberExitMessage) {
             throw new FiberExitException();
         } else if (message instanceof FiberExceptionMessage) {
             throw new RaiseException(((FiberExceptionMessage) message).getException());
         } else if (message instanceof FiberResumeMessage) {
             final FiberResumeMessage resumeMessage = (FiberResumeMessage) message;
-            assert BasicObjectNodes.getContext(fiber).getThreadManager().getCurrentThread() == getFields(resumeMessage.getSendingFiber()).rubyThread;
+            assert BasicObjectNodes.getContext(fiber).getThreadManager().getCurrentThread() == Layouts.FIBER.getFields(resumeMessage.getSendingFiber()).rubyThread;
             if (!(resumeMessage.isYield())) {
-                getFields(fiber).lastResumedByFiber = resumeMessage.getSendingFiber();
+                Layouts.FIBER.getFields(fiber).lastResumedByFiber = resumeMessage.getSendingFiber();
             }
             return resumeMessage.getArgs();
         } else {
@@ -193,25 +173,25 @@ public static Object[] transferControlTo(DynamicObject fromFiber, DynamicObject
 
     public static void shutdown(DynamicObject fiber) {
         assert RubyGuards.isRubyFiber(fiber);
-        assert !getFields(fiber).isRootFiber;
+        assert !Layouts.FIBER.getFields(fiber).isRootFiber;
         sendMessageTo(fiber, new FiberExitMessage());
     }
 
     public static boolean isAlive(DynamicObject fiber) {
         assert RubyGuards.isRubyFiber(fiber);
-        return getFields(fiber).alive;
+        return Layouts.FIBER.getFields(fiber).alive;
     }
 
     public static DynamicObject createRubyFiber(DynamicObject parent, DynamicObject rubyClass, String name) {
         final FiberFields fields = new FiberNodes.FiberFields(parent, false);
         fields.name = name;
-        return FIBER_LAYOUT.createFiber(ClassNodes.CLASS_LAYOUT.getInstanceFactory(rubyClass), fields);
+        return Layouts.FIBER.createFiber(Layouts.CLASS.getInstanceFactory(rubyClass), fields);
     }
 
     public static DynamicObject createRubyFiber(DynamicObject parent, FiberManager fiberManager, ThreadManager threadManager, DynamicObject rubyClass, String name, boolean isRootFiber) {
         final FiberFields fields = new FiberNodes.FiberFields(parent, isRootFiber);
         fields.name = name;
-        return FIBER_LAYOUT.createFiber(ClassNodes.CLASS_LAYOUT.getInstanceFactory(rubyClass), fields);
+        return Layouts.FIBER.createFiber(Layouts.CLASS.getInstanceFactory(rubyClass), fields);
     }
 
     public interface FiberMessage {
@@ -244,7 +224,7 @@ protected Object transfer(VirtualFrame frame, DynamicObject fiber, boolean isYie
             }
 
             DynamicObject currentThread = getContext().getThreadManager().getCurrentThread();
-            if (getFields(fiber).rubyThread != currentThread) {
+            if (Layouts.FIBER.getFields(fiber).rubyThread != currentThread) {
                 CompilerDirectives.transferToInterpreter();
                 throw new RaiseException(getContext().getCoreLibrary().fiberError("fiber called across threads", this));
             }
@@ -304,9 +284,9 @@ public YieldNode(RubyContext context, SourceSection sourceSection) {
         public Object yield(VirtualFrame frame, Object[] args) {
             final DynamicObject currentThread = getContext().getThreadManager().getCurrentThread();
             final DynamicObject yieldingFiber = ThreadNodes.getFiberManager(currentThread).getCurrentFiber();
-            final DynamicObject fiberYieldedTo = getFields(yieldingFiber).lastResumedByFiber;
+            final DynamicObject fiberYieldedTo = Layouts.FIBER.getFields(yieldingFiber).lastResumedByFiber;
 
-            if (getFields(yieldingFiber).isRootFiber || fiberYieldedTo == null) {
+            if (Layouts.FIBER.getFields(yieldingFiber).isRootFiber || fiberYieldedTo == null) {
                 throw new RaiseException(getContext().getCoreLibrary().yieldFromRootFiberError(this));
             }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/FloatNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/FloatNodes.java
@@ -23,6 +23,7 @@
 import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 @CoreClass(name = "Float")
 public abstract class FloatNodes {
@@ -60,7 +61,7 @@ public double add(double a, double b) {
 
         @Specialization(guards = "isRubyBignum(b)")
         public double add(double a, DynamicObject b) {
-            return a + BignumNodes.getBigIntegerValue(b).doubleValue();
+            return a + Layouts.BIGNUM.getValue(b).doubleValue();
         }
 
     }
@@ -84,7 +85,7 @@ public double sub(double a, double b) {
 
         @Specialization(guards = "isRubyBignum(b)")
         public double sub(double a, DynamicObject b) {
-            return a - BignumNodes.getBigIntegerValue(b).doubleValue();
+            return a - Layouts.BIGNUM.getValue(b).doubleValue();
         }
 
         @Specialization(guards = "!isRubyBignum(b)")
@@ -113,7 +114,7 @@ public double mul(double a, double b) {
 
         @Specialization(guards = "isRubyBignum(b)")
         public double mul(double a, DynamicObject b) {
-            return a * BignumNodes.getBigIntegerValue(b).doubleValue();
+            return a * Layouts.BIGNUM.getValue(b).doubleValue();
         }
 
         @Specialization(guards = "!isRubyBignum(b)")
@@ -159,7 +160,7 @@ public Object pow(VirtualFrame frame, double a, double b) {
 
         @Specialization(guards = "isRubyBignum(b)")
         public double pow(double a, DynamicObject b) {
-            return Math.pow(a, BignumNodes.getBigIntegerValue(b).doubleValue());
+            return Math.pow(a, Layouts.BIGNUM.getValue(b).doubleValue());
         }
 
         @Specialization(guards = "!isRubyBignum(b)")
@@ -190,7 +191,7 @@ public double div(double a, double b) {
 
         @Specialization(guards = "isRubyBignum(b)")
         public double div(double a, DynamicObject b) {
-            return a / BignumNodes.getBigIntegerValue(b).doubleValue();
+            return a / Layouts.BIGNUM.getValue(b).doubleValue();
         }
 
         @Specialization(guards = {
@@ -241,7 +242,7 @@ public double mod(double a, double b) {
 
         @Specialization(guards = "isRubyBignum(b)")
         public double mod(double a, DynamicObject b) {
-            return mod(a, BignumNodes.getBigIntegerValue(b).doubleValue());
+            return mod(a, Layouts.BIGNUM.getValue(b).doubleValue());
         }
 
     }
@@ -268,7 +269,7 @@ public DynamicObject divMod(double a, double b) {
 
         @Specialization(guards = "isRubyBignum(b)")
         public DynamicObject divMod(double a, DynamicObject b) {
-            return divModNode.execute(a, BignumNodes.getBigIntegerValue(b));
+            return divModNode.execute(a, Layouts.BIGNUM.getValue(b));
         }
 
     }
@@ -292,7 +293,7 @@ public boolean less(double a, double b) {
 
         @Specialization(guards = "isRubyBignum(b)")
         public boolean lessBignum(double a, DynamicObject b) {
-            return a < BignumNodes.getBigIntegerValue(b).doubleValue();
+            return a < Layouts.BIGNUM.getValue(b).doubleValue();
         }
 
         @Specialization(guards = {
@@ -324,7 +325,7 @@ public boolean lessEqual(double a, double b) {
 
         @Specialization(guards = "isRubyBignum(b)")
         public boolean lessEqual(double a, DynamicObject b) {
-            return a <= BignumNodes.getBigIntegerValue(b).doubleValue();
+            return a <= Layouts.BIGNUM.getValue(b).doubleValue();
         }
 
         @Specialization(guards = {
@@ -377,7 +378,7 @@ public boolean equal(double a, double b) {
 
         @Specialization(guards = "isRubyBignum(b)")
         public boolean equal(double a, DynamicObject b) {
-            return a == BignumNodes.getBigIntegerValue(b).doubleValue();
+            return a == Layouts.BIGNUM.getValue(b).doubleValue();
         }
 
         @Specialization(guards = "!isRubyBignum(b)")
@@ -424,7 +425,7 @@ public int compareInfinity(double a, DynamicObject b) {
 
         @Specialization(guards = {"!isNaN(a)", "!isInfinity(a)", "isRubyBignum(b)"})
         public int compareBignum(double a, DynamicObject b) {
-            return Double.compare(a, BignumNodes.getBigIntegerValue(b).doubleValue());
+            return Double.compare(a, Layouts.BIGNUM.getValue(b).doubleValue());
         }
 
         @Specialization(guards = {"!isNaN(a)", "!isNaN(b)"})
@@ -458,7 +459,7 @@ public boolean greaterEqual(double a, double b) {
 
         @Specialization(guards = "isRubyBignum(b)")
         public boolean greaterEqual(double a, DynamicObject b) {
-            return a >= BignumNodes.getBigIntegerValue(b).doubleValue();
+            return a >= Layouts.BIGNUM.getValue(b).doubleValue();
         }
 
         @Specialization(guards = {
@@ -491,7 +492,7 @@ public boolean greater(double a, double b) {
 
         @Specialization(guards = "isRubyBignum(b)")
         public boolean greater(double a, DynamicObject b) {
-            return a > BignumNodes.getBigIntegerValue(b).doubleValue();
+            return a > Layouts.BIGNUM.getValue(b).doubleValue();
         }
 
         @Specialization(guards = {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/IntegerNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/IntegerNodes.java
@@ -18,6 +18,7 @@
 import org.jruby.truffle.nodes.methods.UnsupportedOperationBehavior;
 import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 import java.math.BigInteger;
 
@@ -148,7 +149,7 @@ public Object times(VirtualFrame frame, long n, DynamicObject block) {
         public Object times(VirtualFrame frame, DynamicObject n, DynamicObject block,
                 @Cached("create(getContext(), getSourceSection())") FixnumOrBignumNode fixnumOrBignumNode) {
 
-            for (BigInteger i = BigInteger.ZERO; i.compareTo(BignumNodes.getBigIntegerValue(n)) < 0; i = i.add(BigInteger.ONE)) {
+            for (BigInteger i = BigInteger.ZERO; i.compareTo(Layouts.BIGNUM.getValue(n)) < 0; i = i.add(BigInteger.ONE)) {
                 yield(frame, block, fixnumOrBignumNode.fixnumOrBignum(i));
             }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/InterpolatedRegexpNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/InterpolatedRegexpNode.java
@@ -17,6 +17,7 @@
 import org.jruby.truffle.nodes.dispatch.CallDispatchHeadNode;
 import org.jruby.truffle.nodes.dispatch.DispatchHeadNodeFactory;
 import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.truffle.translator.BodyTranslator;
 import org.jruby.util.RegexpOptions;
 
@@ -41,7 +42,7 @@ public Object execute(VirtualFrame frame) {
 
         for (int n = 0; n < children.length; n++) {
             final Object child = children[n].execute(frame);
-            strings[n] = org.jruby.RubyString.newString(getContext().getRuntime(), StringNodes.getByteList((DynamicObject) toS.call(frame, child, "to_s", null)));
+            strings[n] = org.jruby.RubyString.newString(getContext().getRuntime(), Layouts.STRING.getByteList((DynamicObject) toS.call(frame, child, "to_s", null)));
         }
 
         final org.jruby.RubyString preprocessed = org.jruby.RubyRegexp.preprocessDRegexp(getContext().getRuntime(), strings, options);
@@ -50,9 +51,9 @@ public Object execute(VirtualFrame frame) {
 
         if (options.isEncodingNone()) {
             if (!BodyTranslator.all7Bit(preprocessed.getByteList().bytes())) {
-                RegexpNodes.getSource(regexp).setEncoding(getContext().getRuntime().getEncodingService().getAscii8bitEncoding());
+                Layouts.REGEXP.getSource(regexp).setEncoding(getContext().getRuntime().getEncodingService().getAscii8bitEncoding());
             } else {
-                RegexpNodes.getSource(regexp).setEncoding(getContext().getRuntime().getEncodingService().getUSAsciiEncoding());
+                Layouts.REGEXP.getSource(regexp).setEncoding(getContext().getRuntime().getEncodingService().getUSAsciiEncoding());
             }
         }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/InterpolatedStringNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/InterpolatedStringNode.java
@@ -24,6 +24,7 @@
 import org.jruby.truffle.nodes.objects.TaintNodeGen;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 /**
  * A list of expressions to build up into a string.
@@ -81,7 +82,7 @@ private DynamicObject concat(Object[] strings) {
                 try {
                     builder.append19(getContext().toJRuby(string));
                 } catch (org.jruby.exceptions.RaiseException e) {
-                    throw new RaiseException(getContext().getCoreLibrary().encodingCompatibilityErrorIncompatible(builder.getEncoding().getCharsetName(), StringNodes.getByteList((DynamicObject) string).getEncoding().getCharsetName(), this));
+                    throw new RaiseException(getContext().getCoreLibrary().encodingCompatibilityErrorIncompatible(builder.getEncoding().getCharsetName(), Layouts.STRING.getByteList((DynamicObject) string).getEncoding().getCharsetName(), this));
                 }
             }
         }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java
@@ -59,6 +59,7 @@
 import org.jruby.truffle.runtime.backtrace.Backtrace;
 import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.core.MethodFilter;
+import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.truffle.runtime.methods.InternalMethod;
 import org.jruby.truffle.runtime.subsystems.FeatureManager;
 import org.jruby.truffle.runtime.subsystems.ThreadManager.BlockingAction;
@@ -138,7 +139,7 @@ public DynamicObject backtick(VirtualFrame frame, DynamicObject command) {
             }
 
             // TODO (nirvdrum 10-Mar-15) This should be using the default external encoding, rather than hard-coded to UTF-8.
-            return createString(resultBuilder.toString(), EncodingNodes.getEncoding(EncodingNodes.getEncoding("UTF-8")));
+            return createString(resultBuilder.toString(), Layouts.ENCODING.getEncoding(EncodingNodes.getEncoding("UTF-8")));
         }
 
     }
@@ -425,8 +426,8 @@ public DynamicObject clone(VirtualFrame frame, DynamicObject self) {
             final DynamicObject newObject = copyNode.executeCopy(frame, self);
 
             // Copy the singleton class if any.
-            if (ClassNodes.isSingleton(BasicObjectNodes.getMetaClass(self))) {
-                ModuleNodes.getFields(singletonClassNode.executeSingletonClass(frame, newObject)).initCopy(BasicObjectNodes.getMetaClass(self));
+            if (Layouts.CLASS.getIsSingleton(Layouts.BASIC_OBJECT.getMetaClass(self))) {
+                Layouts.MODULE.getFields(singletonClassNode.executeSingletonClass(frame, newObject)).initCopy(Layouts.BASIC_OBJECT.getMetaClass(self));
             }
 
             initializeCloneNode.call(frame, newObject, "initialize_clone", null, self);
@@ -529,8 +530,8 @@ public Object evalNoBindingCached(
         ) {
             final DynamicObject callerBinding = getCallerBinding(frame);
 
-            final Object callerSelf = BindingNodes.getSelf(callerBinding);
-            final MaterializedFrame parentFrame = BindingNodes.getFrame(callerBinding);
+            final Object callerSelf = Layouts.BINDING.getSelf(callerBinding);
+            final MaterializedFrame parentFrame = Layouts.BINDING.getFrame(callerBinding);
 
             final InternalMethod method = new InternalMethod(
                     cachedRootNode.getRootNode().getSharedMethodInfo(),
@@ -554,7 +555,7 @@ public Object evalNoBindingCached(
         }, contains = "evalNoBindingCached")
         public Object evalNoBindingUncached(VirtualFrame frame, DynamicObject source, NotProvided binding,
                                             NotProvided filename, NotProvided lineNumber) {
-            return getContext().eval(StringNodes.getByteList(source), getCallerBinding(frame), true, this);
+            return getContext().eval(Layouts.STRING.getByteList(source), getCallerBinding(frame), true, this);
         }
 
         @Specialization(guards = {
@@ -573,7 +574,7 @@ public Object evalNilBinding(VirtualFrame frame, DynamicObject source, Object no
         })
         public Object evalBinding(DynamicObject source, DynamicObject binding, NotProvided filename,
                                   NotProvided lineNumber) {
-            return getContext().eval(StringNodes.getByteList(source), binding, false, this);
+            return getContext().eval(Layouts.STRING.getByteList(source), binding, false, this);
         }
 
         @TruffleBoundary
@@ -583,7 +584,7 @@ public Object evalBinding(DynamicObject source, DynamicObject binding, NotProvid
                 "isRubyString(filename)"})
         public Object evalBindingFilename(DynamicObject source, DynamicObject binding, DynamicObject filename,
                                           NotProvided lineNumber) {
-            return getContext().eval(StringNodes.getByteList(source), binding, false, filename.toString(), this);
+            return getContext().eval(Layouts.STRING.getByteList(source), binding, false, filename.toString(), this);
         }
 
         @TruffleBoundary
@@ -593,7 +594,7 @@ public Object evalBindingFilename(DynamicObject source, DynamicObject binding, D
                 "isRubyString(filename)"})
         public Object evalBindingFilenameLine(DynamicObject source, DynamicObject binding, DynamicObject filename,
                                               int lineNumber) {
-            return getContext().eval(StringNodes.getByteList(source), binding, false, filename.toString(), this);
+            return getContext().eval(Layouts.STRING.getByteList(source), binding, false, filename.toString(), this);
         }
 
         @TruffleBoundary
@@ -609,7 +610,7 @@ protected RootNodeWrapper compileSource(VirtualFrame frame, DynamicObject source
             assert RubyGuards.isRubyString(sourceText);
 
             final DynamicObject callerBinding = getCallerBinding(frame);
-            final MaterializedFrame parentFrame = BindingNodes.getFrame(callerBinding);
+            final MaterializedFrame parentFrame = Layouts.BINDING.getFrame(callerBinding);
 
             final Source source = Source.fromText(sourceText.toString(), "(eval)");
 
@@ -968,7 +969,7 @@ public boolean isInstanceVariableDefinedString(DynamicObject object, DynamicObje
         @TruffleBoundary
         @Specialization(guards = "isRubySymbol(name)")
         public boolean isInstanceVariableDefinedSymbol(DynamicObject object, DynamicObject name) {
-            return BasicObjectNodes.isFieldDefined(object, RubyContext.checkInstanceVariableName(getContext(), SymbolNodes.getString(name), this));
+            return BasicObjectNodes.isFieldDefined(object, RubyContext.checkInstanceVariableName(getContext(), Layouts.SYMBOL.getString(name), this));
         }
 
     }
@@ -989,7 +990,7 @@ public Object instanceVariableGetString(DynamicObject object, DynamicObject name
         @TruffleBoundary
         @Specialization(guards = "isRubySymbol(name)")
         public Object instanceVariableGetSymbol(DynamicObject object, DynamicObject name) {
-            return instanceVariableGet(object, SymbolNodes.getString(name));
+            return instanceVariableGet(object, Layouts.SYMBOL.getString(name));
         }
 
         private Object instanceVariableGet(DynamicObject object, String name) {
@@ -1017,7 +1018,7 @@ public Object instanceVariableSetString(DynamicObject object, DynamicObject name
         @TruffleBoundary
         @Specialization(guards = "isRubySymbol(name)")
         public Object instanceVariableSetSymbol(DynamicObject object, DynamicObject name, Object value) {
-            BasicObjectNodes.setInstanceVariable(object, RubyContext.checkInstanceVariableName(getContext(), SymbolNodes.getString(name), this), value);
+            BasicObjectNodes.setInstanceVariable(object, RubyContext.checkInstanceVariableName(getContext(), Layouts.SYMBOL.getString(name), this), value);
             return value;
         }
 
@@ -1082,7 +1083,7 @@ public boolean isACached(VirtualFrame frame,
         }
 
         public Assumption getUnmodifiedAssumption(DynamicObject module) {
-            return ModuleNodes.getFields(module).getUnmodifiedAssumption();
+            return Layouts.MODULE.getFields(module).getUnmodifiedAssumption();
         }
 
         @Specialization(guards = "isRubyModule(module)")
@@ -1132,14 +1133,14 @@ public DynamicObject proc(DynamicObject block) {
             return ProcNodes.createRubyProc(
                     getContext().getCoreLibrary().getProcClass(),
                     ProcNodes.Type.LAMBDA,
-                    ProcNodes.getSharedMethodInfo(block),
-                    ProcNodes.getCallTargetForLambdas(block),
-                    ProcNodes.getCallTargetForLambdas(block),
-                    ProcNodes.getCallTargetForLambdas(block),
-                    ProcNodes.getDeclarationFrame(block),
-                    ProcNodes.getMethod(block),
-                    ProcNodes.getSelfCapturedInScope(block),
-                    ProcNodes.getBlockCapturedInScope(block));
+                    Layouts.PROC.getSharedMethodInfo(block),
+                    Layouts.PROC.getCallTargetForLambdas(block),
+                    Layouts.PROC.getCallTargetForLambdas(block),
+                    Layouts.PROC.getCallTargetForLambdas(block),
+                    Layouts.PROC.getDeclarationFrame(block),
+                    Layouts.PROC.getMethod(block),
+                    Layouts.PROC.getSelf(block),
+                    Layouts.PROC.getBlock(block));
         }
     }
 
@@ -1276,7 +1277,7 @@ public DynamicObject methodsRegular(VirtualFrame frame, Object self, boolean reg
 
             CompilerDirectives.transferToInterpreter();
             return ArrayNodes.fromObjects(getContext().getCoreLibrary().getArrayClass(),
-                    ModuleNodes.getFields(metaClass).filterMethodsOnObject(regular, MethodFilter.PUBLIC_PROTECTED).toArray());
+                    Layouts.MODULE.getFields(metaClass).filterMethodsOnObject(regular, MethodFilter.PUBLIC_PROTECTED).toArray());
         }
 
         @Specialization(guards = "!regular")
@@ -1333,7 +1334,7 @@ public DynamicObject privateMethods(VirtualFrame frame, Object self, boolean inc
 
             CompilerDirectives.transferToInterpreter();
             return ArrayNodes.fromObjects(getContext().getCoreLibrary().getArrayClass(),
-                    ModuleNodes.getFields(metaClass).filterMethodsOnObject(includeAncestors, MethodFilter.PRIVATE).toArray());
+                    Layouts.MODULE.getFields(metaClass).filterMethodsOnObject(includeAncestors, MethodFilter.PRIVATE).toArray());
         }
 
     }
@@ -1352,14 +1353,14 @@ public DynamicObject proc(DynamicObject block) {
             return ProcNodes.createRubyProc(
                     getContext().getCoreLibrary().getProcClass(),
                     ProcNodes.Type.PROC,
-                    ProcNodes.getSharedMethodInfo(block),
-                    ProcNodes.getCallTargetForProcs(block),
-                    ProcNodes.getCallTargetForProcs(block),
-                    ProcNodes.getCallTargetForLambdas(block),
-                    ProcNodes.getDeclarationFrame(block),
-                    ProcNodes.getMethod(block),
-                    ProcNodes.getSelfCapturedInScope(block),
-                    ProcNodes.getBlockCapturedInScope(block));
+                    Layouts.PROC.getSharedMethodInfo(block),
+                    Layouts.PROC.getCallTargetForProcs(block),
+                    Layouts.PROC.getCallTargetForProcs(block),
+                    Layouts.PROC.getCallTargetForLambdas(block),
+                    Layouts.PROC.getDeclarationFrame(block),
+                    Layouts.PROC.getMethod(block),
+                    Layouts.PROC.getSelf(block),
+                    Layouts.PROC.getBlock(block));
         }
     }
 
@@ -1388,7 +1389,7 @@ public DynamicObject protectedMethods(VirtualFrame frame, Object self, boolean i
 
             CompilerDirectives.transferToInterpreter();
             return ArrayNodes.fromObjects(getContext().getCoreLibrary().getArrayClass(),
-                    ModuleNodes.getFields(metaClass).filterMethodsOnObject(includeAncestors, MethodFilter.PROTECTED).toArray());
+                    Layouts.MODULE.getFields(metaClass).filterMethodsOnObject(includeAncestors, MethodFilter.PROTECTED).toArray());
         }
 
     }
@@ -1418,7 +1419,7 @@ public DynamicObject publicMethods(VirtualFrame frame, Object self, boolean incl
 
             CompilerDirectives.transferToInterpreter();
             return ArrayNodes.fromObjects(getContext().getCoreLibrary().getArrayClass(),
-                    ModuleNodes.getFields(metaClass).filterMethodsOnObject(includeAncestors, MethodFilter.PUBLIC).toArray());
+                    Layouts.MODULE.getFields(metaClass).filterMethodsOnObject(includeAncestors, MethodFilter.PUBLIC).toArray());
         }
 
     }
@@ -1533,7 +1534,7 @@ public boolean require(DynamicObject featureString) {
 
             if (feature.equals("openssl") && RubyCallStack.getCallerFrame(getContext()).getCallNode()
                     .getEncapsulatingSourceSection().getSource().getName().endsWith("securerandom.rb")) {
-                ModuleNodes.getFields(getContext().getCoreLibrary().getObjectClass()).getConstants().remove("OpenSSL");
+                Layouts.MODULE.getFields(getContext().getCoreLibrary().getObjectClass()).getConstants().remove("OpenSSL");
                 throw new RaiseException(getContext().getCoreLibrary().loadErrorCannotLoad(feature, this));
             }
 
@@ -1753,13 +1754,13 @@ public RubyNode coerceToBoolean(RubyNode includeAncestors) {
         public DynamicObject singletonMethods(VirtualFrame frame, Object self, boolean includeAncestors) {
             final DynamicObject metaClass = metaClassNode.executeMetaClass(frame, self);
 
-            if (!ClassNodes.isSingleton(metaClass)) {
+            if (!Layouts.CLASS.getIsSingleton(metaClass)) {
                 return createEmptyArray();
             }
 
             CompilerDirectives.transferToInterpreter();
             return ArrayNodes.fromObjects(getContext().getCoreLibrary().getArrayClass(),
-                    ModuleNodes.getFields(metaClass).filterSingletonMethods(includeAncestors, MethodFilter.PUBLIC_PROTECTED).toArray());
+                    Layouts.MODULE.getFields(metaClass).filterSingletonMethods(includeAncestors, MethodFilter.PUBLIC_PROTECTED).toArray());
         }
 
     }
@@ -1915,7 +1916,7 @@ public DynamicObject formatUncached(
                 throw handleException(e);
             }
 
-            return finishFormat(StringNodes.getByteList(format), result);
+            return finishFormat(Layouts.STRING.getByteList(format), result);
         }
 
         private RuntimeException handleException(PackException exception) {
@@ -1974,7 +1975,7 @@ protected CallTarget compileFormat(DynamicObject format) {
             assert RubyGuards.isRubyString(format);
 
             try {
-                return new FormatParser(getContext()).parse(StringNodes.getByteList(format));
+                return new FormatParser(getContext()).parse(Layouts.STRING.getByteList(format));
             } catch (FormatException e) {
                 CompilerDirectives.transferToInterpreter();
                 throw new RaiseException(getContext().getCoreLibrary().argumentError(e.getMessage(), this));
@@ -2085,7 +2086,7 @@ public String toHexString(long value) {
 
         @Specialization(guards = "isRubyBignum(value)")
         public String toHexString(DynamicObject value) {
-            return BignumNodes.getBigIntegerValue(value).toString(16);
+            return Layouts.BIGNUM.getValue(value).toString(16);
         }
 
     }
@@ -2110,7 +2111,7 @@ public ToSNode(RubyContext context, SourceSection sourceSection) {
         public DynamicObject toS(VirtualFrame frame, Object self) {
             CompilerDirectives.transferToInterpreter();
 
-            String className = ModuleNodes.getFields(classNode.executeGetClass(frame, self)).getName();
+            String className = Layouts.MODULE.getFields(classNode.executeGetClass(frame, self)).getName();
             Object id = objectIDNode.executeObjectID(frame, self);
             String hexID = toHexStringNode.executeToHexString(frame, id);
 
@@ -2141,7 +2142,7 @@ public Object taint(DynamicObject object) {
 
             if (isFrozenNode.executeIsFrozen(object)) {
                 CompilerDirectives.transferToInterpreter();
-                throw new RaiseException(getContext().getCoreLibrary().frozenError(ModuleNodes.getFields(getContext().getCoreLibrary().getLogicalClass(object)).getName(), this));
+                throw new RaiseException(getContext().getCoreLibrary().frozenError(Layouts.MODULE.getFields(getContext().getCoreLibrary().getLogicalClass(object)).getName(), this));
             }
 
             writeTaintNode.execute(object, false);