# HG changeset patch # User Doug Simon # Date 1441642126 -7200 # Node ID 8d95daa4324b4d13cf84d03ab35b7d40509369fd # Parent 23db6926b163fbf0495d2cb0559326a123020ea2 moved cstring utilities into UnsafeUtil and made them require the caller to have the Unsafe capability diff -r 23db6926b163 -r 8d95daa4324b jvmci/jdk.internal.jvmci.common/src/jdk/internal/jvmci/common/UnsafeAccess.java --- a/jvmci/jdk.internal.jvmci.common/src/jdk/internal/jvmci/common/UnsafeAccess.java Mon Sep 07 11:42:32 2015 +0200 +++ b/jvmci/jdk.internal.jvmci.common/src/jdk/internal/jvmci/common/UnsafeAccess.java Mon Sep 07 18:08:46 2015 +0200 @@ -22,9 +22,9 @@ */ package jdk.internal.jvmci.common; -import java.lang.reflect.*; +import java.lang.reflect.Field; -import sun.misc.*; +import sun.misc.Unsafe; public class UnsafeAccess { @@ -42,54 +42,4 @@ throw new RuntimeException("exception while trying to get Unsafe", e); } } - - /** - * Copies the contents of a {@link String} to a native memory buffer as a {@code '\0'} - * terminated C string. The native memory buffer is allocated via - * {@link Unsafe#allocateMemory(long)}. The caller is responsible for releasing the buffer when - * it is no longer needed via {@link Unsafe#freeMemory(long)}. - * - * @return the native memory pointer of the C string created from {@code s} - */ - public static long createCString(String s) { - return writeCString(s, unsafe.allocateMemory(s.length() + 1)); - } - - /** - * Reads a {@code '\0'} terminated C string from native memory and converts it to a - * {@link String}. - * - * @return a Java string - */ - public static String readCString(long address) { - if (address == 0) { - return null; - } - StringBuilder sb = new StringBuilder(); - for (int i = 0;; i++) { - char c = (char) unsafe.getByte(address + i); - if (c == 0) { - break; - } - sb.append(c); - } - return sb.toString(); - } - - /** - * Writes the contents of a {@link String} to a native memory buffer as a {@code '\0'} - * terminated C string. The caller is responsible for ensuring the buffer is at least - * {@code s.length() + 1} bytes long. The caller is also responsible for releasing the buffer - * when it is no longer. - * - * @return the value of {@code buf} - */ - public static long writeCString(String s, long buf) { - int size = s.length(); - for (int i = 0; i < size; i++) { - unsafe.putByte(buf + i, (byte) s.charAt(i)); - } - unsafe.putByte(buf + size, (byte) '\0'); - return buf; - } } diff -r 23db6926b163 -r 8d95daa4324b jvmci/jdk.internal.jvmci.common/src/jdk/internal/jvmci/common/UnsafeUtil.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jvmci/jdk.internal.jvmci.common/src/jdk/internal/jvmci/common/UnsafeUtil.java Mon Sep 07 18:08:46 2015 +0200 @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2012, 2012, 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. + * + * 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.internal.jvmci.common; + +import sun.misc.Unsafe; + +/** + * Utilities for operating on raw memory with {@link Unsafe}. + */ +public class UnsafeUtil { + + /** + * Copies the contents of a {@link String} to a native memory buffer as a {@code '\0'} + * terminated C string. The native memory buffer is allocated via + * {@link Unsafe#allocateMemory(long)}. The caller is responsible for releasing the buffer when + * it is no longer needed via {@link Unsafe#freeMemory(long)}. + * + * @return the native memory pointer of the C string created from {@code s} + */ + public static long createCString(Unsafe unsafe, String s) { + return writeCString(unsafe, s, unsafe.allocateMemory(s.length() + 1)); + } + + /** + * Reads a {@code '\0'} terminated C string from native memory and converts it to a + * {@link String}. + * + * @return a Java string + */ + public static String readCString(Unsafe unsafe, long address) { + if (address == 0) { + return null; + } + StringBuilder sb = new StringBuilder(); + for (int i = 0;; i++) { + char c = (char) unsafe.getByte(address + i); + if (c == 0) { + break; + } + sb.append(c); + } + return sb.toString(); + } + + /** + * Writes the contents of a {@link String} to a native memory buffer as a {@code '\0'} + * terminated C string. The caller is responsible for ensuring the buffer is at least + * {@code s.length() + 1} bytes long. The caller is also responsible for releasing the buffer + * when it is no longer. + * + * @return the value of {@code buf} + */ + public static long writeCString(Unsafe unsafe, String s, long buf) { + int size = s.length(); + for (int i = 0; i < size; i++) { + unsafe.putByte(buf + i, (byte) s.charAt(i)); + } + unsafe.putByte(buf + size, (byte) '\0'); + return buf; + } +} diff -r 23db6926b163 -r 8d95daa4324b jvmci/jdk.internal.jvmci.hotspot/src/jdk/internal/jvmci/hotspot/HotSpotVMConfig.java --- a/jvmci/jdk.internal.jvmci.hotspot/src/jdk/internal/jvmci/hotspot/HotSpotVMConfig.java Mon Sep 07 11:42:32 2015 +0200 +++ b/jvmci/jdk.internal.jvmci.hotspot/src/jdk/internal/jvmci/hotspot/HotSpotVMConfig.java Mon Sep 07 18:08:46 2015 +0200 @@ -23,6 +23,7 @@ package jdk.internal.jvmci.hotspot; import static jdk.internal.jvmci.common.UnsafeAccess.*; +import static jdk.internal.jvmci.common.UnsafeUtil.readCString; import java.lang.reflect.*; import java.util.*; @@ -329,17 +330,17 @@ public String getTypeName() { long typeNameAddress = unsafe.getAddress(entryAddress + gHotSpotVMStructEntryTypeNameOffset); - return readCString(typeNameAddress); + return readCString(unsafe, typeNameAddress); } public String getFieldName() { long fieldNameAddress = unsafe.getAddress(entryAddress + gHotSpotVMStructEntryFieldNameOffset); - return readCString(fieldNameAddress); + return readCString(unsafe, fieldNameAddress); } public String getTypeString() { long typeStringAddress = unsafe.getAddress(entryAddress + gHotSpotVMStructEntryTypeStringOffset); - return readCString(typeStringAddress); + return readCString(unsafe, typeStringAddress); } public boolean isStatic() { @@ -440,12 +441,12 @@ public String getTypeName() { long typeNameAddress = unsafe.getAddress(entryAddress + gHotSpotVMTypeEntryTypeNameOffset); - return readCString(typeNameAddress); + return readCString(unsafe, typeNameAddress); } public String getSuperclassName() { long superclassNameAddress = unsafe.getAddress(entryAddress + gHotSpotVMTypeEntrySuperclassNameOffset); - return readCString(superclassNameAddress); + return readCString(unsafe, superclassNameAddress); } public boolean isOopType() { @@ -486,7 +487,7 @@ public String getName() { long nameAddress = unsafe.getAddress(address + nameOffset); - return readCString(nameAddress); + return readCString(unsafe, nameAddress); } public abstract long getValue(); @@ -665,12 +666,12 @@ public String getType() { long typeAddress = unsafe.getAddress(entryAddress + typeOffset); - return readCString(typeAddress); + return readCString(unsafe, typeAddress); } public String getName() { long nameAddress = unsafe.getAddress(entryAddress + nameOffset); - return readCString(nameAddress); + return readCString(unsafe, nameAddress); } public long getAddr() { @@ -689,7 +690,7 @@ return Double.valueOf(unsafe.getDouble(getAddr())); case "ccstr": case "ccstrlist": - return readCString(getAddr()); + return readCString(unsafe, getAddr()); default: throw new JVMCIError(getType()); }