truffle: graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiUtil.java comparison

comparison graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiUtil.java @ 4547:a3cdfa2be94e

Allow to intrinsify an invoke with a deoptimize node. Make debug output more relaxed wrt to null in FrameMap.method

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Thu, 09 Feb 2012 20:05:59 +0100
parents	14a00ee82980
children	e43d36482d12

comparison

equal deleted inserted replaced

-:df329f268a05
+:a3cdfa2be94e
 * @param withEnclosingClass specifies if the returned name should be qualified with the name(s) of the enclosing
 *            class/classes of {@code clazz} (if any). This option is ignored if {@code clazz} denotes an anonymous
 *            or local class.
 * @return the simple name
 */
-public static String getSimpleName(Class<?> clazz, boolean withEnclosingClass) {
+public static String getSimpleName(Class< ? > clazz, boolean withEnclosingClass) {
 final String simpleName = clazz.getSimpleName();
 if (simpleName.length() != 0) {
 if (withEnclosingClass) {
 String prefix = "";
-Class<?> enclosingClass = clazz;
+Class< ? > enclosingClass = clazz;
 while ((enclosingClass = enclosingClass.getEnclosingClass()) != null) {
 prefix = prefix + enclosingClass.getSimpleName() + ".";
 }
 return prefix + simpleName;
 }
 return name.substring(index + 1);
 }
 public static final int K = 1024;
 public static final int M = 1024 * 1024;
 public static boolean isOdd(int n) {
 return (n & 1) == 1;
 }
 public static boolean isEven(int n) {
 public static boolean isPowerOf2(long val) {
 return val != 0 && (val & val - 1) == 0;
 }
 /**
-* Computes the log (base 2) of the specified integer, rounding down.
+* Computes the log (base 2) of the specified integer, rounding down. (E.g {@code log2(8) = 3}, {@code log2(21) = 4}
-* (E.g {@code log2(8) = 3}, {@code log2(21) = 4})
+* )
 *
 * @param val the value
 * @return the log base 2 of the value
 */
 public static int log2(int val) {
 assert val > 0 && isPowerOf2(val);
 return 31 - Integer.numberOfLeadingZeros(val);
 }
 /**
-* Computes the log (base 2) of the specified long, rounding down.
+* Computes the log (base 2) of the specified long, rounding down. (E.g {@code log2(8) = 3}, {@code log2(21) = 4})
-* (E.g {@code log2(8) = 3}, {@code log2(21) = 4})
 *
 * @param val the value
 * @return the log base 2 of the value
 */
 public static int log2(long val) {
 return (size + align - 1) & ~(align - 1);
 }
 /**
 * Gets a word with the nth bit set.
+*
 * @param n the nth bit to set
 * @return an integer value with the nth bit set
 */
 public static int nthBit(int n) {
 return n >= Integer.SIZE ? 0 : 1 << n;
 }
 /**
 * Gets a word with the right-most n bits set.
+*
 * @param n the number of right most bits to set
 * @return an integer value with the right-most n bits set
 */
 public static int rightNBits(int n) {
 return nthBit(n) - 1;
 if (kind.isPrimitive() || kind == CiKind.Void) {
 return kind.javaName;
 }
 return internalNameToJava(riType.name(), qualified);
 }
 /**
 * Converts a given type to its Java programming language name. The following are examples of strings returned by
 * this method:
 *
 * <pre>
 sb.append(ch);
 }
 }
 return sb.toString();
 }
 /**
 * Gets a string for a given field formatted according to a given format specification. A format specification is
 * composed of characters that are to be copied verbatim to the result and specifiers that denote an attribute of
 * the field that is to be copied to the result. A specifier is a single character preceded by a '%' character. The
 * accepted specifiers and the field attributes they denote are described below:
 *     '%'       | A '%' character                                      | "%"
 * </pre>
 *
 * @param format a format specification
 * @param field the field to be formatted
-* @param kinds if {@code true} then {@code field}'s type is printed in the
+* @param kinds if {@code true} then {@code field}'s type is printed in the {@linkplain CiKind#jniName JNI} form of
-*            {@linkplain CiKind#jniName JNI} form of its {@linkplain CiKind kind}
+*            its {@linkplain CiKind kind}
 * @return the result of formatting this field according to {@code format}
 * @throws IllegalFormatException if an illegal specifier is encountered in {@code format}
 */
 public static String format(String format, RiField field) throws IllegalFormatException {
 final StringBuilder sb = new StringBuilder();
 public static String toInternalName(String className) {
 return "L" + className.replace('.', '/') + ";";
 }
 /**
-* Creates a set that uses reference-equality instead of {@link Object#equals(Object)}
+* Creates a set that uses reference-equality instead of {@link Object#equals(Object)} when comparing values.
-* when comparing values.
 *
 * @param <T> the type of elements in the set
 * @return a set based on reference-equality
 */
 public static <T> Set<T> newIdentityHashSet() {
 return Collections.newSetFromMap(new IdentityHashMap<T, Boolean>());
 }
 /**
-* Prepends the String {@code indentation} to every line in String {@code lines},
+* Prepends the String {@code indentation} to every line in String {@code lines}, including a possibly non-empty
-* including a possibly non-empty line following the final newline.
+* line following the final newline.
 */
 public static String indent(String lines, String indentation) {
 if (lines.length() == 0) {
 return lines;
 }
 }
 return sb.toString();
 }
 /**
-* Convenient shortcut for calling {@link #appendLocation(StringBuilder, RiMethod, int)}
+* Convenient shortcut for calling {@link #appendLocation(StringBuilder, RiMethod, int)} without having to supply a
-* without having to supply a a {@link StringBuilder} instance and convert the result
+* a {@link StringBuilder} instance and convert the result to a string.
-* to a string.
 */
 public static String toLocation(RiResolvedMethod method, int bci) {
 return appendLocation(new StringBuilder(), method, bci).toString();
 }
+/**
-/**
+* Appends a string representation of a location specified by a given method and bci to a given
-* Appends a string representation of a location specified by a given method and bci to
+* {@link StringBuilder}. If a stack trace element with a non-null file name and non-negative line number is
-* a given {@link StringBuilder}. If a stack trace element with a non-null file name
+* {@linkplain RiMethod#toStackTraceElement(int) available} for the given method, then the string returned is the
-* and non-negative line number is {@linkplain RiMethod#toStackTraceElement(int) available}
+* {@link StackTraceElement#toString()} value of the stack trace element, suffixed by the bci location. For example:
-* for the given method, then the string returned is the {@link StackTraceElement#toString()}
+*
-* value of the stack trace element, suffixed by the bci location. For example:
 * <pre>
 *     java.lang.String.valueOf(String.java:2930) [bci: 12]
 * </pre>
-* Otherwise, the string returned is the value of {@code CiUtil.format("%H.%n(%p)"}, suffixed
+*
-* by the bci location. For example:
+* Otherwise, the string returned is the value of {@code CiUtil.format("%H.%n(%p)"}, suffixed by the bci location.
+* For example:
+*
 * <pre>
 *     java.lang.String.valueOf(int) [bci: 12]
 * </pre>
 *
 * @param sb
 * @param method
 * @param bci
 * @return
 */
 public static StringBuilder appendLocation(StringBuilder sb, RiResolvedMethod method, int bci) {
-StackTraceElement ste = method.toStackTraceElement(bci);
+if (method != null) {
-if (ste.getFileName() != null && ste.getLineNumber() > 0) {
+StackTraceElement ste = method.toStackTraceElement(bci);
-sb.append(ste);
+if (ste.getFileName() != null && ste.getLineNumber() > 0) {
-} else {
+sb.append(ste);
-sb.append(CiUtil.format("%H.%n(%p)", method));
+} else {
+sb.append(CiUtil.format("%H.%n(%p)", method));
+}
 }
 return sb.append(" [bci: ").append(bci).append(']');
 }
 /**
 /**
 * Formats a location present in a register or frame reference map.
 */
 public static class RefMapFormatter {
 /**
 * The size of a stack slot.
 */
 public final int slotSize;
 public final CiRegister fp;
 public final CiArchitecture arch;
 /**
-* The offset (in bytes) from the slot pointed to by {@link #fp} to the slot
+* The offset (in bytes) from the slot pointed to by {@link #fp} to the slot corresponding to bit 0 in the frame
-* corresponding to bit 0 in the frame reference map.
+* reference map.
 */
 public final int refMapToFPOffset;
 public RefMapFormatter(CiArchitecture arch, int slotSize, CiRegister fp, int refMapToFPOffset) {
 this.arch = arch;
 result[i + j] = signature.argumentKindAt(j, true);
 }
 return result;
 }
-public static Class<?>[] signatureToTypes(RiSignature signature, RiResolvedType accessingClass) {
+public static Class< ? >[] signatureToTypes(RiSignature signature, RiResolvedType accessingClass) {
 int count = signature.argumentCount(false);
-Class<?>[] result = new Class<?>[count];
+Class< ? >[] result = new Class< ? >[count];
 for (int i = 0; i < result.length; ++i) {
 result[i] = signature.argumentTypeAt(i, accessingClass).resolve(accessingClass).toJava();
 }
 return result;
 }

Mercurial > hg > truffle

comparison graal/com.oracle.max.cri/src/com/oracle/max/cri/ci/CiUtil.java @ 4547:a3cdfa2be94e