1 /*

     2  * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 package jdk.vm.ci.hotspot;

    24 

    25 import java.io.ByteArrayOutputStream;

    26 import java.io.DataOutputStream;

    27 import java.io.IOException;

    28 import java.security.MessageDigest;

    29 import java.security.NoSuchAlgorithmException;

    30 import java.util.Arrays;

    31 

    32 import jdk.vm.ci.common.JVMCIError;

    33 import jdk.vm.ci.meta.ResolvedJavaMethod;

    34 import jdk.vm.ci.meta.ResolvedJavaType;

    35 import jdk.vm.ci.meta.SpeculationLog.SpeculationReasonEncoding;

    36 

    37 /**

    38  * Implements a {@link SpeculationReasonEncoding} that {@linkplain #getByteArray() produces} a byte

    39  * array. Data is added via a {@link DataOutputStream}. When producing the final byte array, if the

    40  * total length of data exceeds the length of a SHA-1 digest, then a SHA-1 digest of the data is

    41  * produced instead.

    42  */

    43 final class HotSpotSpeculationEncoding extends ByteArrayOutputStream implements SpeculationReasonEncoding {

    44 

    45     private DataOutputStream dos = new DataOutputStream(this);

    46     private byte[] result;

    47 

    48     HotSpotSpeculationEncoding() {

    49         super(SHA1_LENGTH);

    50     }

    51 

    52     private void checkOpen() {

    53         if (result != null) {

    54             throw new IllegalArgumentException("Cannot update closed speculation encoding");

    55         }

    56     }

    57 

    58     private static final int NULL_METHOD = -1;

    59     private static final int NULL_TYPE = -2;

    60     private static final int NULL_STRING = -3;

    61 

    62     @Override

    63     public void addByte(int value) {

    64         checkOpen();

    65         try {

    66             dos.writeByte(value);

    67         } catch (IOException e) {

    68             throw new InternalError(e);

    69         }

    70     }

    71 

    72     @Override

    73     public void addShort(int value) {

    74         checkOpen();

    75         try {

    76             dos.writeShort(value);

    77         } catch (IOException e) {

    78             throw new InternalError(e);

    79         }

    80     }

    81 

    82     @Override

    83     public void addMethod(ResolvedJavaMethod method) {

    84         if (!addNull(method, NULL_METHOD)) {

    85             checkOpen();

    86             if (method instanceof HotSpotResolvedJavaMethodImpl) {

    87                 try {

    88                     dos.writeLong(((HotSpotResolvedJavaMethodImpl) method).getMetaspaceMethod());

    89                 } catch (IOException e) {

    90                     throw new InternalError(e);

    91                 }

    92             } else {

    93                 throw new IllegalArgumentException("Cannot encode unsupported type " + method.getClass().getName() + ": " + method.format("%H.%n(%p)"));

    94             }

    95         }

    96     }

    97 

    98     @Override

    99     public void addType(ResolvedJavaType type) {

   100         if (!addNull(type, NULL_TYPE)) {

   101             checkOpen();

   102             if (type instanceof HotSpotResolvedObjectTypeImpl) {

   103                 try {

   104                     dos.writeLong(((HotSpotResolvedObjectTypeImpl) type).getMetaspaceKlass());

   105                 } catch (IOException e) {

   106                     throw new InternalError(e);

   107                 }

   108             } else {

   109                 throw new IllegalArgumentException("Cannot encode unsupported type " + type.getClass().getName() + ": " + type.toClassName());

   110             }

   111         }

   112     }

   113 

   114     @Override

   115     public void addString(String value) {

   116         if (!addNull(value, NULL_STRING)) {

   117             checkOpen();

   118             try {

   119                 dos.writeChars(value);

   120             } catch (IOException e) {

   121                 throw new InternalError(e);

   122             }

   123         }

   124     }

   125 

   126     @Override

   127     public void addInt(int value) {

   128         checkOpen();

   129         try {

   130             dos.writeInt(value);

   131         } catch (IOException e) {

   132             throw new InternalError(e);

   133         }

   134     }

   135 

   136     @Override

   137     public void addLong(long value) {

   138         checkOpen();

   139         try {

   140             dos.writeLong(value);

   141         } catch (IOException e) {

   142             throw new InternalError(e);

   143         }

   144     }

   145 

   146     private boolean addNull(Object o, int nullValue) {

   147         if (o == null) {

   148             addInt(nullValue);

   149             return true;

   150         }

   151         return false;

   152     }

   153 

   154     /**

   155      * Prototype SHA1 digest that is cloned before use.

   156      */

   157     private static final MessageDigest SHA1 = getSHA1();

   158     private static final int SHA1_LENGTH = SHA1.getDigestLength();

   159 

   160     private static MessageDigest getSHA1() {

   161         try {

   162             MessageDigest sha1 = MessageDigest.getInstance("SHA-1");

   163             sha1.clone();

   164             return sha1;

   165         } catch (CloneNotSupportedException | NoSuchAlgorithmException e) {

   166             // Should never happen given that SHA-1 is mandated in a

   167             // compliant Java platform implementation.

   168             throw new JVMCIError("Expect a cloneable implementation of a SHA-1 message digest to be available", e);

   169         }

   170     }

   171 

   172     /**

   173      * Gets the final encoded byte array and closes this encoding such that any further attempts to

   174      * update it result in an {@link IllegalArgumentException}.

   175      */

   176     byte[] getByteArray() {

   177         if (result == null) {

   178             if (count > SHA1_LENGTH) {

   179                 try {

   180                     MessageDigest md = (MessageDigest) SHA1.clone();

   181                     md.update(buf, 0, count);

   182                     result = md.digest();

   183                 } catch (CloneNotSupportedException e) {

   184                     throw new InternalError(e);

   185                 }

   186             } else {

   187                 if (buf.length == count) {

   188                     // No need to copy the byte array

   189                     return buf;

   190                 }

   191                 result = Arrays.copyOf(buf, count);

   192             }

   193             dos = null;

   194         }

   195         return result;

   196     }

   197 }