1 /* 2 * Copyright (c) 2013, 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 org.graalvm.compiler.debug; 24 25 import java.io.PrintStream; 26 import java.util.Collection; 27 import java.util.EnumMap; 28 import java.util.Map; 29 30 import org.graalvm.compiler.debug.internal.DebugScope; 31 32 public class DelegatingDebugConfig implements DebugConfig { 33 34 protected final DebugConfig delegate; 35 36 /** 37 * The features of a {@link DelegatingDebugConfig} that can be force 38 * {@linkplain DelegatingDebugConfig#enable(Feature) enabled}/ 39 * {@linkplain DelegatingDebugConfig#disable(Feature) disabled} or 40 * {@linkplain DelegatingDebugConfig#delegate(Feature) delegated}. 41 */ 42 public enum Feature { 43 /** 44 * @see Debug#isLogEnabledForMethod() 45 */ 46 LOG_METHOD, 47 /** 48 * @see Debug#isDumpEnabledForMethod() 49 */ 50 DUMP_METHOD, 51 /** 52 * @see Debug#isVerifyEnabled() 53 */ 54 VERIFY, 55 /** 56 * @see Debug#isVerifyEnabledForMethod() 57 */ 58 VERIFY_METHOD, 59 /** 60 * @see Debug#isCountEnabled() 61 */ 62 COUNT, 63 /** 64 * @see Debug#isMethodMeterEnabled() 65 */ 66 METHOD_METRICS, 67 /** 68 * @see Debug#isMemUseTrackingEnabled() 69 */ 70 TRACK_MEM_USE, 71 /** 72 * @see Debug#isTimeEnabled() 73 */ 74 TIME, 75 /** 76 * @see DebugConfig#interceptException(Throwable) 77 */ 78 INTERCEPT 79 } 80 81 private final Map<Feature, Boolean> featureState = new EnumMap<>(Feature.class); 82 83 /** 84 * The debug levels of a {@link DelegatingDebugConfig} than can be 85 * {@linkplain DelegatingDebugConfig#override(Level, int) overridden} or 86 * {@linkplain DelegatingDebugConfig#delegate(Level) delegated}. 87 */ 88 public enum Level { 89 LOG, 90 DUMP 91 } 92 93 private final Map<Level, Integer> levelState = new EnumMap<>(Level.class); 94 95 /** 96 * Creates a config that delegates to the {@link DebugScope#getConfig() current config}. 97 */ 98 public DelegatingDebugConfig() { 99 this(DebugScope.getConfig()); 100 } 101 102 /** 103 * Creates a config that delegates to a given config. 104 */ 105 public DelegatingDebugConfig(DebugConfig delegate) { 106 this.delegate = delegate; 107 } 108 109 public DelegatingDebugConfig enable(Feature feature) { 110 featureState.put(feature, Boolean.TRUE); 111 return this; 112 } 113 114 public DelegatingDebugConfig disable(Feature feature) { 115 featureState.put(feature, Boolean.FALSE); 116 return this; 117 } 118 119 public DelegatingDebugConfig override(Level level, int newLevel) { 120 levelState.put(level, newLevel); 121 return this; 122 } 123 124 public DelegatingDebugConfig delegate(Feature feature) { 125 featureState.put(feature, null); 126 return this; 127 } 128 129 public DelegatingDebugConfig delegate(Level level) { 130 levelState.put(level, null); 131 return this; 132 } 133 134 @Override 135 public int getLogLevel() { 136 Integer ls = levelState.get(Level.LOG); 137 if (ls == null) { 138 return delegate.getLogLevel(); 139 } 140 return ls.intValue(); 141 } 142 143 @Override 144 public boolean isLogEnabledForMethod() { 145 Boolean fs = featureState.get(Feature.LOG_METHOD); 146 if (fs == null) { 147 return delegate.isLogEnabledForMethod(); 148 } 149 return fs.booleanValue(); 150 } 151 152 @Override 153 public boolean isCountEnabled() { 154 Boolean fs = featureState.get(Feature.COUNT); 155 if (fs == null) { 156 return delegate.isCountEnabled(); 157 } 158 return fs.booleanValue(); 159 } 160 161 @Override 162 public boolean isMemUseTrackingEnabled() { 163 Boolean fs = featureState.get(Feature.TRACK_MEM_USE); 164 if (fs == null) { 165 return delegate.isMemUseTrackingEnabled(); 166 } 167 return fs.booleanValue(); 168 } 169 170 @Override 171 public int getDumpLevel() { 172 Integer ls = levelState.get(Level.DUMP); 173 if (ls == null) { 174 return delegate.getDumpLevel(); 175 } 176 return ls.intValue(); 177 } 178 179 @Override 180 public boolean isDumpEnabledForMethod() { 181 Boolean fs = featureState.get(Feature.DUMP_METHOD); 182 if (fs == null) { 183 return delegate.isDumpEnabledForMethod(); 184 } 185 return fs.booleanValue(); 186 } 187 188 @Override 189 public boolean isVerifyEnabled() { 190 Boolean fs = featureState.get(Feature.VERIFY); 191 if (fs == null) { 192 return delegate.isVerifyEnabled(); 193 } 194 return fs.booleanValue(); 195 } 196 197 @Override 198 public boolean isVerifyEnabledForMethod() { 199 Boolean fs = featureState.get(Feature.VERIFY_METHOD); 200 if (fs == null) { 201 return delegate.isVerifyEnabledForMethod(); 202 } 203 return fs.booleanValue(); 204 } 205 206 @Override 207 public boolean isTimeEnabled() { 208 Boolean fs = featureState.get(Feature.TIME); 209 if (fs == null) { 210 return delegate.isTimeEnabled(); 211 } 212 return fs.booleanValue(); 213 } 214 215 @Override 216 public boolean isMethodMeterEnabled() { 217 Boolean fs = featureState.get(Feature.METHOD_METRICS); 218 if (fs == null) { 219 return delegate.isMethodMeterEnabled(); 220 } 221 return fs.booleanValue(); 222 } 223 224 @Override 225 public RuntimeException interceptException(Throwable e) { 226 Boolean fs = featureState.get(Feature.INTERCEPT); 227 if (fs == null || fs) { 228 return delegate.interceptException(e); 229 } 230 return null; 231 } 232 233 @Override 234 public Collection<DebugDumpHandler> dumpHandlers() { 235 return delegate.dumpHandlers(); 236 } 237 238 @Override 239 public Collection<DebugVerifyHandler> verifyHandlers() { 240 return delegate.verifyHandlers(); 241 } 242 243 @Override 244 public PrintStream output() { 245 return delegate.output(); 246 } 247 248 @Override 249 public void addToContext(Object o) { 250 delegate.addToContext(o); 251 } 252 253 @Override 254 public void removeFromContext(Object o) { 255 delegate.removeFromContext(o); 256 } 257 258 }