1 /*
   2  * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
   3  * 
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * The contents of this file are subject to the terms of either the Universal Permissive License
   7  * v 1.0 as shown at http://oss.oracle.com/licenses/upl
   8  *
   9  * or the following license:
  10  *
  11  * Redistribution and use in source and binary forms, with or without modification, are permitted
  12  * provided that the following conditions are met:
  13  * 
  14  * 1. Redistributions of source code must retain the above copyright notice, this list of conditions
  15  * and the following disclaimer.
  16  * 
  17  * 2. Redistributions in binary form must reproduce the above copyright notice, this list of
  18  * conditions and the following disclaimer in the documentation and/or other materials provided with
  19  * the distribution.
  20  * 
  21  * 3. Neither the name of the copyright holder nor the names of its contributors may be used to
  22  * endorse or promote products derived from this software without specific prior written permission.
  23  * 
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
  25  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  26  * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  27  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  30  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
  31  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33 package org.openjdk.jmc.agent.util;
  34 
  35 import java.lang.reflect.Array;
  36 import java.lang.reflect.Field;



  37 import java.util.List;
  38 import java.util.logging.Level;
  39 import java.util.logging.Logger;
  40 
  41 import org.openjdk.jmc.agent.Parameter;
  42 import org.openjdk.jmc.agent.jfr.impl.JFRUtils;
  43 import org.objectweb.asm.MethodVisitor;
  44 import org.objectweb.asm.Opcodes;
  45 import org.objectweb.asm.Type;
  46 
  47 import sun.misc.Unsafe;

  48 
  49 /**
  50  * Helper methods for doing transforms.
  51  */
  52 public final class TypeUtils {
  53         private static final String NULL_REFERENCE_STRING = "null"; //$NON-NLS-1$
  54         /**
  55          * The internal name of this class.
  56          */
  57         public static final String INAME = Type.getInternalName(TypeUtils.class);
  58         public static final Type OBJECT_TYPE = Type.getObjectType("java/lang/Object"); //$NON-NLS-1$
  59         public static final Type OBJECT_ARRAY_TYPE = Type.getObjectType("[Ljava/lang/Object;"); //$NON-NLS-1$
  60         public static final Type STRING_TYPE = Type.getType("Ljava/lang/String;"); //$NON-NLS-1$
  61 
  62         public static final Object STRING_INTERNAL_NAME = "java/lang/String"; //$NON-NLS-1$
  63 











  64         /**
  65          * The file extension for java source files (.java).
  66          */
  67         public static final String JAVA_FILE_EXTENSION = ".java"; //$NON-NLS-1$
  68 
  69         private TypeUtils() {
  70                 throw new UnsupportedOperationException("Toolkit!"); //$NON-NLS-1$
  71         }
  72 
  73         public static Object box(byte val) {
  74                 return val;
  75         }
  76 
  77         public static Object box(short val) {
  78                 return val;
  79         }
  80 
  81         public static Object box(char val) {
  82                 return val;
  83         }
  84 
  85         public static Object box(int val) {
  86                 return val;
  87         }
  88 
  89         public static Object box(long val) {
  90                 return val;
  91         }
  92 
  93         public static Object box(float val) {
  94                 return val;
  95         }
  96 
  97         public static Object box(double val) {
  98                 return val;
  99         }
 100 
 101         public static String toString(Object o) {
 102                 if (o == null) {
 103                         return NULL_REFERENCE_STRING;
 104                 }
 105                 if (o.getClass().isArray()) {
 106                         return toString(o, Array.getLength(o));
 107                 }
 108                 return String.valueOf(o);
 109         }
 110 
 111         /**
 112          * Type agnostic array toString() which also handles primitive arrays.
 113          */
 114         private static String toString(Object o, int length) {
 115                 int iMax = length - 1;
 116                 if (iMax == -1) {
 117                         return "[]"; //$NON-NLS-1$
 118                 }
 119 
 120                 StringBuilder b = new StringBuilder();
 121                 b.append('[');
 122                 for (int i = 0;; i++) {
 123                         b.append(Array.get(o, i));
 124                         if (i == iMax) {
 125                                 return b.append(']').toString();
 126                         }
 127                         b.append(", "); //$NON-NLS-1$
 128                 }

 129         }
 130 
 131         /**
 132          * Ensure that the operand is on the stack before calling. If type is void, this is a noop, and
 133          * depending on your use case you may instead want to push Opcodes.ACONST_NULL.

 134          */
 135         public static void visitBox(MethodVisitor mv, Type type) {
 136                 switch (type.getSort()) {
 137                 case Type.VOID:
 138                         break;
 139                 case Type.BOOLEAN:
 140                         emitBox(mv, "(Z)Ljava/lang/Object;"); //$NON-NLS-1$
 141                         break;
 142                 case Type.BYTE:
 143                         emitBox(mv, "(B)Ljava/lang/Object;"); //$NON-NLS-1$
 144                         break;
 145                 case Type.CHAR:
 146                         emitBox(mv, "(C)Ljava/lang/Object;"); //$NON-NLS-1$
 147                         break;
 148                 case Type.SHORT:
 149                         emitBox(mv, "(S)Ljava/lang/Object;"); //$NON-NLS-1$
 150                         break;
 151                 case Type.INT:
 152                         emitBox(mv, "(I)Ljava/lang/Object;"); //$NON-NLS-1$
 153                         break;
 154                 case Type.LONG:
 155                         emitBox(mv, "(J)Ljava/lang/Object;"); //$NON-NLS-1$
 156                         break;
 157                 case Type.FLOAT:
 158                         emitBox(mv, "(F)Ljava/lang/Object;"); //$NON-NLS-1$
 159                         break;
 160                 case Type.DOUBLE:
 161                         emitBox(mv, "(D)Ljava/lang/Object;"); //$NON-NLS-1$
 162                         break;
 163                 }
 164         }
 165 
 166         private static void emitBox(MethodVisitor mv, String desc) {
 167                 mv.visitMethodInsn(Opcodes.INVOKESTATIC, INAME, "box", desc, false); //$NON-NLS-1$
 168         }
 169 
 170         public static boolean isValidJavaIdentifier(String identifier) {
 171                 if (identifier == null || identifier.length() == 0) {
 172                         return false;
 173                 }
 174 
 175                 if (!Character.isJavaIdentifierStart(identifier.charAt(0))) {
 176                         return false;
 177                 }
 178 
 179                 for (int i = 1; i < identifier.length(); i++) {
 180                         if (!Character.isJavaIdentifierPart(identifier.charAt(i))) {
 181                                 return false;
 182                         }
 183                 }
 184                 return true;
 185         }
 186 
 187         public static String deriveIdentifierPart(String str) {
 188                 StringBuilder builder = new StringBuilder();
 189 
 190                 for (int i = 0; i < str.length(); i++) {
 191                         char c = str.charAt(i);
 192                         if (Character.isJavaIdentifierPart(c)) {
 193                                 builder.append(c);
 194                         }
 195                 }
 196                 builder.setCharAt(0, Character.toUpperCase(builder.toString().charAt(0)));
 197                 return builder.toString();
 198         }
 199 
 200         public static String getPathPart(String fqcn) {
 201                 int lastSlashIndex = fqcn.lastIndexOf('/');
 202                 if (lastSlashIndex >= 0) {
 203                         return fqcn.substring(0, lastSlashIndex + 1);
 204                 }
 205                 return fqcn;
 206         }
 207 
 208         public static String getNamePart(String fqcn) {
 209                 int lastSlashIndex = fqcn.lastIndexOf('/');
 210                 if (lastSlashIndex >= 0) {
 211                         return fqcn.substring(lastSlashIndex + 1);
 212                 }
 213                 return fqcn;
 214         }
 215 
 216         public static Unsafe getUnsafe() {
 217                 // Lovely, but this seems to be the only way
 218                 try {
 219                         Field f = Unsafe.class.getDeclaredField("theUnsafe"); //$NON-NLS-1$
 220                         f.setAccessible(true);
 221                         return (Unsafe) f.get(null);
 222                 } catch (Exception e) {
 223                         Logger.getLogger(JFRUtils.class.getName()).log(Level.SEVERE, "Could not access Unsafe!", e); //$NON-NLS-1$
 224                 }
 225                 return null;
 226         }
 227 
 228         public static void stringify(MethodVisitor mv, Parameter param, Type argumentType) {
 229                 mv.visitMethodInsn(Opcodes.INVOKESTATIC, INAME, "toString", //$NON-NLS-1$
 230                                 "(Ljava/lang/Object;)Ljava/lang/String;", false); //$NON-NLS-1$
 231         }
 232 
 233         public static boolean shouldStringify(Parameter param, Type argumentType) {
 234                 if (argumentType.getSort() == Type.ARRAY || argumentType.getSort() == Type.OBJECT) {
 235                         return !argumentType.getInternalName().equals(STRING_INTERNAL_NAME);
 236                 }
 237                 return false;
 238         }
 239 
 240         public static Parameter findReturnParam(List<Parameter> parameters) {
 241                 for (Parameter p : parameters) {
 242                         if (p.isReturn()) {
 243                                 return p;
 244                         }
 245                 }
 246                 return null;
 247         }
 248 
 249         /**
 250          * Transforms a FQN in internal form, so that it can be used in e.g. formal descriptors.

 251          *
 252          * @param className
 253          *            the fully qualified class name in internal form.
 254          * @return the transformed class name.
 255          */
 256         public static String parameterize(String className) {
 257                 return "L" + className + ";"; //$NON-NLS-1$ //$NON-NLS-2$





































































 258         }
 259 }
--- EOF ---