1 /* 2 * Copyright (c) 2012, 2014, 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.meta; 24 25 /** 26 * Manages unique deoptimization reasons. Reasons are embedded in compiled code and can be 27 * invalidated at run time. Subsequent compilations then should not speculate again on such 28 * invalidated reasons to avoid repeated deoptimization. 29 * 30 * All methods of this interface are called by the compiler. There is no need for API to register 31 * failed speculations during deoptimization, since every VM has different needs there. 32 */ 33 public interface SpeculationLog { 34 /** 35 * Marker interface for speculation objects that can be added to the speculation log. 36 */ 37 public interface SpeculationReason { 38 } 39 40 /** 41 * Marker class that indicates that a speculation has no reason. 42 */ 43 final class NoSpeculationReason implements SpeculationReason { 44 } 45 46 class Speculation { 47 private SpeculationReason reason; 48 49 public Speculation(SpeculationReason reason) { 50 this.reason = reason; 51 } 52 53 public SpeculationReason getReason() { 54 return reason; 55 } 56 57 @Override 58 public String toString() { 59 return reason.toString(); 60 } 61 62 @Override 63 public boolean equals(Object obj) { 64 if (obj instanceof Speculation) { 65 Speculation other = (Speculation) obj; 66 return reason.equals(other.reason); 67 } 68 return false; 69 } 70 71 @Override 72 public int hashCode() { 73 return getReason().hashCode(); 74 } 75 } 76 77 Speculation NO_SPECULATION = new Speculation(new NoSpeculationReason()); 78 79 /** 80 * Must be called before compilation, i.e., before a compiler calls {@link #maySpeculate}. 81 */ 82 void collectFailedSpeculations(); 83 84 /** 85 * If this method returns true, the compiler is allowed to {@link #speculate} with the given 86 * reason. 87 */ 88 boolean maySpeculate(SpeculationReason reason); 89 90 /** 91 * Registers a speculation performed by the compiler. The compiler must guard every call to this 92 * method for a specific reason with a call to {@link #maySpeculate(SpeculationReason)}. 93 * 94 * This API is subject to a benign race where a during the course of a compilation another 95 * thread might fail a speculation such that {@link #maySpeculate(SpeculationReason)} will 96 * return false but an earlier call returned true. This method will still return a working 97 * {@link Speculation} in that case but the compile will eventually be invalidated and the 98 * compile attempted again without the now invalid speculation. 99 * 100 * @param reason an object representing the reason for the speculation 101 * @return a compiler constant encapsulating the provided reason. It is usually passed as an 102 * argument to the deoptimization function. 103 */ 104 Speculation speculate(SpeculationReason reason); 105 106 /** 107 * Returns if this log has speculations. 108 * 109 * @return true if there are speculations, false otherwise 110 */ 111 boolean hasSpeculations(); 112 113 /** 114 * Given a {@link JavaConstant} previously returned from 115 * {@link MetaAccessProvider#encodeSpeculation(Speculation)} return the original 116 * {@link Speculation} object. 117 */ 118 Speculation lookupSpeculation(JavaConstant constant); 119 }