Add support for bitfields in StructWrapper

gilles-duboscq · gilles-duboscq · commit d9609a155c68 · 2025-06-18T20:29:44.000+02:00
diff --git a/espresso/src/com.oracle.truffle.espresso.mokapot/src/structs.c b/espresso/src/com.oracle.truffle.espresso.mokapot/src/structs.c
@@ -33,7 +33,7 @@
 #define JNI_STRUCT_MEMBER_LIST(V) \
     V(JavaVMAttachArgs, version) \
     V(JavaVMAttachArgs, name) \
-    V(JavaVMAttachArgs, group) \
+    V(JavaVMAttachArgs, group)
 
 #define JVM_STRUCT_MEMBER_LIST(V) \
     V(jdk_version_info, jdk_version)
@@ -172,15 +172,24 @@
     V(_jvmtiEventCallbacks, reserved85) \
     V(_jvmtiEventCallbacks, SampledObjectAlloc)
 
+#define JMM_STRUCT_BITFIELD_MEMBER_LIST(V) \
+    V(jmmOptionalSupport, isLowMemoryDetectionSupported) \
+    V(jmmOptionalSupport, isCompilationTimeMonitoringSupported) \
+    V(jmmOptionalSupport, isThreadContentionMonitoringSupported) \
+    V(jmmOptionalSupport, isCurrentThreadCpuTimeSupported) \
+    V(jmmOptionalSupport, isOtherThreadCpuTimeSupported) \
+    V(jmmOptionalSupport, isObjectMonitorUsageSupported) \
+    V(jmmOptionalSupport, isSynchronizerUsageSupported) \
+    V(jmmOptionalSupport, isThreadAllocatedMemorySupported) \
+    V(jmmOptionalSupport, isRemoteDiagnosticCommandsSupported)
+
 #define MEMBER_INFO_STRUCT_MEMBER_LIST(V) \
     V(member_info, id) \
     V(member_info, offset) \
     V(member_info, next)
 
 #define JNI_STRUCT_LIST(V) \
-    V(JavaVMAttachArgs) \
-    V(JavaVMAttachArgs) \
-    V(JavaVMAttachArgs) \
+    V(JavaVMAttachArgs)
 
 #define JVM_STRUCT_LIST(V) \
     V(jdk_version_info)
@@ -224,6 +233,8 @@
     JVMTI_STRUCT_MEMBER_LIST(V) \
     MEMBER_INFO_STRUCT_MEMBER_LIST(V)
 
+#define STRUCT_BITFIELD_MEMBER_LIST_LIST(V)
+
 void add_member_info(member_info** info, char* id, size_t offset) {
     member_info* current = malloc(sizeof(struct member_info));
     current->id = id;
@@ -263,6 +274,47 @@ JNIEXPORT void JNICALL initializeStructs(void (*notify_member_offset_init)(void
   STRUCT_MEMBER_LIST_LIST(MEMBER_INFO__)
   #undef MEMBER_INFO__
 
+  // from com.oracle.svm.hosted.c.codegen.QueryCodeWriter#visitStructBitfieldInfo
+  #define MEMBER_INFO__(STRUCT_NAME, MEMBER_NAME) \
+    {                                             \
+      struct _w {                                 \
+        STRUCT_NAME s;                           \
+        jlong pad;                                \
+      } w;                                        \
+      char *p;                                    \
+      size_t byte_offset;                         \
+      unsigned char start_bit = 0, end_bit = 0;   \
+      jlong v;                                    \
+      jlong all_bits_set = -1;                    \
+      memset(&w, 0x0, sizeof(w));                 \
+      w.s.MEMBER_NAME = all_bits_set;             \
+      p = (char*)&w.s;                            \
+      byte_offset = 0;                            \
+      while (byte_offset < sizeof(w.s) && *(p + byte_offset) == 0) { \
+        byte_offset++;                            \
+      }                                           \
+      if (byte_offset >= sizeof(w.s)) {           \
+        start_bit = end_bit = -1;\
+      } else {                                    \
+        v = *((jlong*) (p + byte_offset));        \
+        while ((v & 0x1) == 0) {                  \
+          start_bit++;                            \
+          v = v >> 1;                             \
+        }                                         \
+        end_bit = start_bit;                      \
+        while (v != 1) {                          \
+          end_bit++;                              \
+          v = v >> 1;                             \
+        }                                         \
+      }                                           \
+      add_member_info(info, #STRUCT_NAME "." #MEMBER_NAME, byte_offset); \
+      add_member_info(info, #STRUCT_NAME "." #MEMBER_NAME ".StartBit", start_bit); \
+      add_member_info(info, #STRUCT_NAME "." #MEMBER_NAME ".EndBit", end_bit + 1); \
+    }
+
+    STRUCT_BITFIELD_MEMBER_LIST_LIST(MEMBER_INFO__)
+  #undef MEMBER_INFO__
+
   #define STRUCT_INFO__(STRUCT_NAME) \
     add_member_info(info, #STRUCT_NAME, sizeof(struct STRUCT_NAME));
 
diff --git a/espresso/src/com.oracle.truffle.espresso.processor/src/com/oracle/truffle/espresso/processor/NativeType.java b/espresso/src/com.oracle.truffle.espresso.processor/src/com/oracle/truffle/espresso/processor/NativeType.java
@@ -39,4 +39,5 @@ public enum NativeType {
 
     OBJECT, // word-sized handle
     POINTER,
+    BITFIELD_INT,
 }
diff --git a/espresso/src/com.oracle.truffle.espresso.processor/src/com/oracle/truffle/espresso/processor/StructsProcessor.java b/espresso/src/com.oracle.truffle.espresso.processor/src/com/oracle/truffle/espresso/processor/StructsProcessor.java
@@ -93,8 +93,10 @@ public class StructsProcessor extends AbstractProcessor {
     private static final String STRUCTS_CLASS = "Structs";
 
     // Methods
-    private static final String GET_INFO = "getInfo";
+    private static final String GET_STRUCT_SIZE = "getStructSize";
     private static final String GET_OFFSET = "getOffset";
+    private static final String GET_START_BIT = "getStartBit";
+    private static final String GET_END_BIT = "getEndBit";
     private static final String GET = "get";
     private static final String PUT = "put";
     private static final String GET_UNCACHED = "getUncached";
@@ -229,7 +231,7 @@ private String processStruct(String strName, List<?> memberNamesList, List<?> ty
             nativeTypes.add(NativeType.valueOf(type.getSimpleName().toString()));
         }
 
-        String className = ProcessorUtils.removeUnderscores(strName); // Replace '_j' with 'J'
+        String className = removeUnderscores(strName); // Replace '_j' with 'J'
         // Generate code
         String source = generateStruct(strName, members, nativeTypes, length, className);
         // Commit and write to files.
@@ -266,13 +268,12 @@ private static String generateStruct(String strName, List<String> members, List<
                         .withSuperClass(STRUCT_STORAGE_CLASS + "<" + className + "." + wrapperName + ">");
 
         // Generate the fields:
-        // - One to store the struct size
         // - One per member to store their offsets
-        generateFields(struct, members);
+        generateFields(struct, members, typesList, length);
 
         // Generate the constructor.
         // Use passed MemberOffsetGetter.
-        generateConstructor(struct, strName, members, className);
+        generateConstructor(struct, strName, members, typesList, length, className);
 
         // Generate the wrapper structure that will access the native struct java-like.
         // It simply wraps a byte buffer around the pointer, and uses offsets in parent class to
@@ -285,20 +286,32 @@ private static String generateStruct(String strName, List<String> members, List<
         return structFile.build();
     }
 
-    private static void generateFields(ClassBuilder struct, List<String> members) {
-        for (String member : members) {
+    private static void generateFields(ClassBuilder struct, List<String> members, List<NativeType> typesList, int length) {
+        for (int i = 0; i < length; i++) {
+            String member = members.get(i);
+            NativeType type = typesList.get(i);
             struct.withField(new FieldBuilder("int", member).withQualifiers(new ModifierBuilder().asFinal()));
+            if (type == NativeType.BITFIELD_INT) {
+                struct.withField(new FieldBuilder("byte", member + "StartBit").withQualifiers(new ModifierBuilder().asFinal()));
+                struct.withField(new FieldBuilder("byte", member + "EndBit").withQualifiers(new ModifierBuilder().asFinal()));
+            }
         }
     }
 
-    private static void generateConstructor(ClassBuilder struct, String strName, List<String> members, String className) {
+    private static void generateConstructor(ClassBuilder struct, String strName, List<String> members, List<NativeType> typesList, int length, String className) {
         MethodBuilder constructor = new MethodBuilder(className) //
                         .withParams(argument(MEMBER_OFFSET_GETTER_CLASS, MEMBER_OFFSET_GETTER_ARG)) //
                         .asConstructor();
 
-        constructor.addBodyLine("super(", call(MEMBER_OFFSET_GETTER_ARG, GET_INFO, new String[]{stringify(strName)}), ");");
-        for (String member : members) {
+        constructor.addBodyLine("super(", call(MEMBER_OFFSET_GETTER_ARG, GET_STRUCT_SIZE, new String[]{stringify(strName)}), ");");
+        for (int i = 0; i < length; i++) {
+            String member = members.get(i);
+            NativeType type = typesList.get(i);
             constructor.addBodyLine(assignment(member, "(int) " + call(MEMBER_OFFSET_GETTER_ARG, GET_OFFSET, new String[]{stringify(strName), stringify(member)})));
+            if (type == NativeType.BITFIELD_INT) {
+                constructor.addBodyLine(assignment(member + "StartBit", "(byte) " + call(MEMBER_OFFSET_GETTER_ARG, GET_START_BIT, new String[]{stringify(strName), stringify(member)})));
+                constructor.addBodyLine(assignment(member + "EndBit", "(byte) " + call(MEMBER_OFFSET_GETTER_ARG, GET_END_BIT, new String[]{stringify(strName), stringify(member)})));
+            }
         }
 
         struct.withMethod(constructor);
@@ -325,12 +338,17 @@ private static void generateWrapper(ClassBuilder struct, List<String> members, L
 
             MethodBuilder getter = new MethodBuilder(methodName) //
                             .withModifiers(new ModifierBuilder().asPublic()) //
-                            .withReturnType(argType) //
-                            .addBodyLine("return ", call(null, GET + callSuffix, new String[]{member}), ';');
+                            .withReturnType(argType);
             MethodBuilder setter = new MethodBuilder(methodName) //
                             .withModifiers(new ModifierBuilder().asPublic()) //
-                            .withParams(argument(argType, VALUE)) //
-                            .addBodyLine(call(null, PUT + callSuffix, new String[]{member, VALUE}), ';');
+                            .withParams(argument(argType, VALUE));
+            if (type == NativeType.BITFIELD_INT) {
+                getter.addBodyLine("return ", call(null, GET + callSuffix, new String[]{member, member + "StartBit", member + "EndBit"}), ';');
+                setter.addBodyLine(call(null, PUT + callSuffix, new String[]{member, member + "StartBit", member + "EndBit", VALUE}), ';');
+            } else {
+                getter.addBodyLine("return ", call(null, GET + callSuffix, new String[]{member}), ';');
+                setter.addBodyLine(call(null, PUT + callSuffix, new String[]{member, VALUE}), ';');
+            }
             wrapper.withMethod(getter);
             wrapper.withMethod(setter);
         }
@@ -399,57 +417,37 @@ private static void generateOptionalMemberInfo(MethodBuilder constructor, List<S
     }
 
     private static String nativeTypeToMethodSuffix(NativeType type) {
-        switch (type) {
-            case BOOLEAN:
-                return "Boolean";
-            case BYTE:
-                return "Byte";
-            case CHAR:
-                return "Char";
-            case SHORT:
-                return "Short";
-            case INT:
-                return "Int";
-            case LONG:
-                return "Long";
-            case FLOAT:
-                return "Float";
-            case DOUBLE:
-                return "Double";
-            case OBJECT:
-                return "Object";
-            case POINTER:
-                return "Pointer";
-            default:
-                return "";
-        }
+        return switch (type) {
+            case VOID -> "";
+            case BOOLEAN -> "Boolean";
+            case BYTE -> "Byte";
+            case CHAR -> "Char";
+            case SHORT -> "Short";
+            case INT -> "Int";
+            case LONG -> "Long";
+            case FLOAT -> "Float";
+            case DOUBLE -> "Double";
+            case OBJECT -> "Object";
+            case POINTER -> "Pointer";
+            case BITFIELD_INT -> "BitFieldInt";
+        };
     }
 
     private static String nativeTypeToArgType(NativeType type) {
-        switch (type) {
-            case BOOLEAN:
-                return "boolean";
-            case BYTE:
-                return "byte";
-            case CHAR:
-                return "char";
-            case SHORT:
-                return "short";
-            case INT:
-                return "int";
-            case LONG:
-                return "long";
-            case FLOAT:
-                return "float";
-            case DOUBLE:
-                return "double";
-            case OBJECT:
-                return "StaticObject";
-            case POINTER:
-                return "TruffleObject";
-            default:
-                return "";
-        }
+        return switch (type) {
+            case VOID -> "";
+            case BOOLEAN -> "boolean";
+            case BYTE -> "byte";
+            case CHAR -> "char";
+            case SHORT -> "short";
+            case INT -> "int";
+            case LONG -> "long";
+            case FLOAT -> "float";
+            case DOUBLE -> "double";
+            case OBJECT -> "StaticObject";
+            case POINTER -> "TruffleObject";
+            case BITFIELD_INT -> "int";
+        };
     }
 
 }
diff --git a/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/ffi/NativeType.java b/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/ffi/NativeType.java
@@ -47,4 +47,5 @@ public enum NativeType {
 
     OBJECT, // word-sized handle
     POINTER,
+    BITFIELD_INT,
 }
diff --git a/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/vm/structs/MemberOffsetGetter.java b/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/vm/structs/MemberOffsetGetter.java
@@ -23,9 +23,21 @@
 package com.oracle.truffle.espresso.vm.structs;
 
 public interface MemberOffsetGetter {
-    long getInfo(String structName);
+    long getInfo(String key);
+
+    default long getStructSize(String structName) {
+        return getInfo(structName);
+    }
 
     default long getOffset(String structName, String memberName) {
         return getInfo(structName + "." + memberName);
     }
+
+    default int getStartBit(String structName, String memberName) {
+        return Math.toIntExact(getInfo(structName + "." + memberName + ".StartBit"));
+    }
+
+    default int getEndBit(String structName, String memberName) {
+        return Math.toIntExact(getInfo(structName + "." + memberName + ".EndBit"));
+    }
 }
diff --git a/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/vm/structs/StructWrapper.java b/espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/vm/structs/StructWrapper.java
@@ -780,6 +780,53 @@ protected void putInt(int offset, int value) {
         buffer.putInt(offset, value);
     }
 
+    protected int getBitFieldInt(int offset, byte startBit, byte endBit) {
+        assert 0 <= startBit && startBit < 8 : startBit;
+        assert endBit > 0 : endBit;
+        assert startBit != endBit : startBit + "!=" + endBit;
+        assert endBit - startBit <= 32 : startBit + ".." + endBit;
+        long v = getBits(offset, endBit) >> startBit;
+        long mask = (1L << (endBit - startBit)) - 1;
+        return Math.toIntExact(v & mask);
+    }
+
+    private long getBits(int offset, byte endBit) {
+        long v;
+        if (endBit <= 8) {
+            v = buffer.get(offset) & 0xff;
+        } else if (endBit <= 16) {
+            v = buffer.getChar(offset);
+        } else if (endBit <= 32) {
+            v = buffer.getInt(offset) & 0xffff_ffffL;
+        } else {
+            v = buffer.getLong(offset);
+        }
+        return v;
+    }
+
+    protected void putBitFieldInt(int offset, byte startBit, byte endBit, int value) {
+        assert 0 <= startBit && startBit < 8 : startBit;
+        assert endBit > 0 : endBit;
+        assert startBit != endBit : startBit + "!=" + endBit;
+        assert endBit - startBit <= 32 : startBit + ".." + endBit;
+        long mask = ((1L << (endBit - startBit)) - 1) << startBit;
+        long v = getBits(offset, endBit);
+        v = (v & ~mask) | (((long) value << startBit) & mask);
+        putBits(offset, endBit, v);
+    }
+
+    private void putBits(int offset, byte endBit, long v) {
+        if (endBit <= 8) {
+            buffer.put(offset, (byte) v);
+        } else if (endBit <= 16) {
+            buffer.putChar(offset, (char) v);
+        } else if (endBit <= 32) {
+            buffer.putInt(offset, (int) v);
+        } else {
+            buffer.putLong(offset, v);
+        }
+    }
+
     protected float getFloat(int offset) {
         return buffer.getFloat(offset);
     }

Original file line number	Diff line number	Diff line change
`@@ -39,4 +39,5 @@ public enum NativeType {`
`39`	`39`
`40`	`40`	`OBJECT, // word-sized handle`
`41`	`41`	`POINTER,`
	`42`	`+ BITFIELD_INT,`
`42`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,4 +47,5 @@ public enum NativeType {`
`47`	`47`
`48`	`48`	`OBJECT, // word-sized handle`
`49`	`49`	`POINTER,`
	`50`	`+ BITFIELD_INT,`
`50`	`51`	`}`