added jdk.graal.compiler.word.WordFactory

Author: dougxc

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/test/CheckGraalInvariants.java

@@ -337,6 +337,7 @@ public static void runTest(InvariantsTool tool) {
         verifiers.add(new VerifyVirtualizableUsage());
         verifiers.add(new VerifyUpdateUsages());
         verifiers.add(new VerifyLibGraalContextChecks());
+        verifiers.add(new VerifyWordFactoryUsage());
         verifiers.add(new VerifyBailoutUsage());
         verifiers.add(new VerifySystemPropertyUsage());
         verifiers.add(new VerifyInstanceOfUsage());

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/test/VerifyWordFactoryUsage.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.graal.compiler.core.test;
+
+import jdk.graal.compiler.nodes.StructuredGraph;
+import jdk.graal.compiler.nodes.java.MethodCallTargetNode;
+import jdk.graal.compiler.nodes.spi.CoreProviders;
+import jdk.graal.compiler.phases.VerifyPhase;
+import jdk.vm.ci.meta.MetaUtil;
+
+/**
+ * Ensures that Graal compiler code uses {@link jdk.graal.compiler.word.WordFactory} instead of
+ * {@link org.graalvm.word.WordFactory} to create word values.
+ */
+public class VerifyWordFactoryUsage extends VerifyPhase<CoreProviders> {
+
+    @Override
+    public boolean checkContract() {
+        return false;
+    }
+
+    @Override
+    protected void verify(StructuredGraph graph, CoreProviders context) {
+
+        String badWordFactory = MetaUtil.toInternalName(org.graalvm.word.WordFactory.class.getName());
+
+        for (MethodCallTargetNode t : graph.getNodes(MethodCallTargetNode.TYPE)) {
+            if (t.targetMethod().getDeclaringClass().getName().equals(badWordFactory)) {
+                throw new VerificationError("accessing %s in %s is prohibited - use %s instead",
+                                badWordFactory,
+                                graph.method().format("%H.%n(%p)"),
+                                jdk.graal.compiler.word.WordFactory.class.getName());
+
+            }
+        }
+    }
+}

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/word/Word.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -35,8 +35,6 @@
 import org.graalvm.word.SignedWord;
 import org.graalvm.word.UnsignedWord;
 import org.graalvm.word.WordBase;
-import org.graalvm.word.WordFactory;
-import org.graalvm.word.impl.WordBoxFactory;
 
 import jdk.graal.compiler.core.common.calc.Condition;
 import jdk.graal.compiler.core.common.calc.UnsignedMath;
@@ -63,14 +61,6 @@ public abstract class Word implements SignedWord, UnsignedWord, Pointer {
 
     private static final Unsafe UNSAFE = Unsafe.getUnsafe();
 
-    static {
-        BoxFactoryImpl.initialize();
-    }
-
-    public static void ensureInitialized() {
-        /* Calling this method ensures that the static initializer has been executed. */
-    }
-
     /**
      * Links a method to a canonical operation represented by an {@link Opcode} val.
      */
@@ -119,19 +109,6 @@ public enum Opcode {
         TO_RAW_VALUE,
     }
 
-    static class BoxFactoryImpl extends WordBoxFactory {
-        static void initialize() {
-            assert boxFactory == null : "BoxFactory must be initialized only once.";
-            boxFactory = new BoxFactoryImpl();
-        }
-
-        @SuppressWarnings("unchecked")
-        @Override
-        public <T extends WordBase> T boxImpl(long val) {
-            return (T) HostedWord.boxLong(val);
-        }
-    }
-
     /*
      * Outside users must use the different signed() and unsigned() methods to ensure proper
      * expansion of 32-bit values on 64-bit systems.

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/word/WordFactory.java

@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package jdk.graal.compiler.word;
+
+import org.graalvm.word.PointerBase;
+import org.graalvm.word.SignedWord;
+import org.graalvm.word.UnsignedWord;
+import org.graalvm.word.WordBase;
+import org.graalvm.word.impl.WordFactoryOpcode;
+import org.graalvm.word.impl.WordFactoryOperation;
+
+/**
+ * Provides factory methods to create boxed {@link WordBase} objects specific to the class loader
+ * loading this class. This avoids type confusion caused by using
+ * {@link org.graalvm.word.WordFactory} which can lead word objects specific to one class loader
+ * (e.g. the libgraal class loader) into code expecting word objects loaded by another class loader
+ * (e.g. the native image class loader).
+ */
+public final class WordFactory {
+
+    private WordFactory() {
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T extends WordBase> T box(long val) {
+        return (T) HostedWord.boxLong(val);
+    }
+
+    /**
+     * @see org.graalvm.word.WordFactory#zero()
+     */
+    @WordFactoryOperation(opcode = WordFactoryOpcode.ZERO)
+    public static <T extends WordBase> T zero() {
+        return box(0L);
+    }
+
+    /**
+     * @see org.graalvm.word.WordFactory#nullPointer()
+     */
+    @WordFactoryOperation(opcode = WordFactoryOpcode.ZERO)
+    public static <T extends PointerBase> T nullPointer() {
+        return box(0L);
+    }
+
+    /**
+     * @see org.graalvm.word.WordFactory#pointer(long)
+     */
+    @WordFactoryOperation(opcode = WordFactoryOpcode.FROM_UNSIGNED)
+    public static <T extends PointerBase> T pointer(long val) {
+        return box(val);
+    }
+
+    /**
+     * @see org.graalvm.word.WordFactory#unsigned(int)
+     */
+    @WordFactoryOperation(opcode = WordFactoryOpcode.FROM_UNSIGNED)
+    public static <T extends UnsignedWord> T unsigned(int val) {
+        return box(val & 0xffffffffL);
+    }
+
+    /**
+     * @see org.graalvm.word.WordFactory#unsigned(long)
+     */
+    @WordFactoryOperation(opcode = WordFactoryOpcode.FROM_UNSIGNED)
+    public static <T extends UnsignedWord> T unsigned(long val) {
+        return box(val);
+    }
+
+    /**
+     * @see org.graalvm.word.WordFactory#signed(int)
+     */
+    @WordFactoryOperation(opcode = WordFactoryOpcode.FROM_SIGNED)
+    public static <T extends SignedWord> T signed(int val) {
+        return box(val);
+    }
+
+    /**
+     * @see org.graalvm.word.WordFactory#signed(long)
+     */
+    @WordFactoryOperation(opcode = WordFactoryOpcode.FROM_SIGNED)
+    public static <T extends SignedWord> T signed(long val) {
+        return box(val);
+    }
+}

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/word/WordTypes.java

@@ -24,24 +24,26 @@
  */
 package jdk.graal.compiler.word;
 
-import static org.graalvm.nativeimage.ImageInfo.inImageBuildtimeCode;
-
 import jdk.graal.compiler.core.common.Fields;
 import jdk.graal.compiler.core.common.type.AbstractObjectStamp;
 import jdk.graal.compiler.core.common.type.Stamp;
 import jdk.graal.compiler.core.common.type.StampFactory;
+import jdk.graal.compiler.debug.GraalError;
 import jdk.graal.compiler.graph.Node;
 import jdk.graal.compiler.nodes.StructuredGraph;
 import jdk.graal.compiler.nodes.ValueNode;
 import jdk.graal.compiler.nodes.type.StampTool;
+import org.graalvm.nativeimage.ImageInfo;
 import org.graalvm.word.WordBase;
-import org.graalvm.word.WordFactory;
 
 import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.JavaType;
 import jdk.vm.ci.meta.MetaAccessProvider;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
+import org.graalvm.word.impl.WordFactoryOperation;
+
+import java.util.List;
 
 /**
  * Encapsulates information for Java types representing raw words (as opposed to Objects).
@@ -62,7 +64,7 @@ public class WordTypes {
     /**
      * Resolved type for {@link WordFactory}.
      */
-    private final ResolvedJavaType wordFactoryType;
+    private final List<ResolvedJavaType> wordFactoryTypes;
 
     /**
      * Resolved type for {@link ObjectAccess}.
@@ -81,24 +83,29 @@ public WordTypes(MetaAccessProvider metaAccess, JavaKind wordKind) {
         this.wordBaseType = metaAccess.lookupJavaType(WordBase.class);
         this.wordBaseClass = WordBase.class;
         this.wordImplType = metaAccess.lookupJavaType(Word.class);
-        this.wordFactoryType = metaAccess.lookupJavaType(WordFactory.class);
+        this.wordFactoryTypes = List.of(
+                        metaAccess.lookupJavaType(org.graalvm.word.WordFactory.class),
+                        metaAccess.lookupJavaType(WordFactory.class));
         this.objectAccessType = metaAccess.lookupJavaType(ObjectAccess.class);
         this.barrieredAccessType = metaAccess.lookupJavaType(BarrieredAccess.class);
 
-        if (!inImageBuildtimeCode()) {
-            Word.ensureInitialized();
-        }
         this.wordImplType.initialize();
     }
 
     /**
      * Determines if a given method denotes a word operation.
      */
     public boolean isWordOperation(ResolvedJavaMethod targetMethod) {
-        final boolean isWordFactory = wordFactoryType.equals(targetMethod.getDeclaringClass());
+        final boolean isWordFactory = wordFactoryTypes.contains(targetMethod.getDeclaringClass());
         if (isWordFactory) {
             return !targetMethod.isConstructor();
         }
+        if (ImageInfo.inImageBuildtimeCode()) {
+            // Can only retrieve annotations at libgraal build time
+            GraalError.guarantee(targetMethod.getAnnotation(WordFactoryOperation.class) == null,
+                            "%s.wordFactoryTypes should include %s", WordTypes.class.getName(), targetMethod.getDeclaringClass().getName());
+        }
+
         final boolean isObjectAccess = objectAccessType.equals(targetMethod.getDeclaringClass());
         final boolean isBarrieredAccess = barrieredAccessType.equals(targetMethod.getDeclaringClass());
         if (isObjectAccess || isBarrieredAccess) {