/*
* Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package compiler.compilercontrol.share.scenario;
import compiler.compilercontrol.share.JSONFile;
import compiler.compilercontrol.share.method.MethodDescriptor;
import compiler.compilercontrol.share.method.MethodGenerator;
import compiler.compilercontrol.share.pool.PoolHelper;
import jdk.test.lib.util.Pair;
import java.lang.reflect.Executable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.stream.Collectors;
/**
* Directive file and state builder class
*/
public class DirectiveBuilder implements StateBuilder<CompileCommand> {
private static final List<Pair<Executable, Callable<?>>> METHODS
= new PoolHelper().getAllMethods();
private final Map<Executable, State> stateMap = new HashMap<>();
private final String fileName;
private final Map<MethodDescriptor, List<CompileCommand>> matchBlocks
= new LinkedHashMap<>();
private final List<CompileCommand> inlines = new ArrayList<>();
private boolean isFileValid = true;
public DirectiveBuilder(String fileName) {
this.fileName = fileName;
}
@Override
public List<String> getOptions() {
List<String> options = new ArrayList<>();
if (!matchBlocks.isEmpty()) {
// add option only if there are any directive available
options.add("-XX:CompilerDirectivesFile=" + fileName);
}
return options;
}
@Override
public List<CompileCommand> getCompileCommands() {
return matchBlocks.keySet().stream()
// only method descriptor is required to check print_directives
.map(md -> new CompileCommand(null, md, null, null))
.collect(Collectors.toList());
}
@Override
public boolean isValid() {
// Invalid directives file makes VM exit with error code
return isFileValid;
}
@Override
public Map<Executable, State> getStates() {
writeDirectiveFile();
if (isFileValid) {
// Build states for each method according to match blocks
for (Pair<Executable, Callable<?>> pair : METHODS) {
State state = getState(pair);
if (state != null) {
stateMap.put(pair.first, state);
}
}
return stateMap;
} else {
// return empty map because invalid file doesn't change states
return new HashMap<>();
}
}
private void writeDirectiveFile() {
try (DirectiveWriter dirFile = new DirectiveWriter(fileName)) {
for (MethodDescriptor matchDescriptor : matchBlocks.keySet()) {
// Write match block with all options converted from commands
dirFile.match(matchDescriptor);
for (CompileCommand compileCommand :
matchBlocks.get(matchDescriptor)) {
handleCommand(dirFile, compileCommand);
}
if ("Inlinee.caller()".matches(matchDescriptor.getRegexp())
&& !inlines.isEmpty()) {
// Got a *.* match block, where inline would be written
writeInlines(dirFile);
inlines.clear();
}
dirFile.end(); // ends match block
}
/*
* Write inline directive in the end to the latest match block
* if we didn't do this before
* Inlinee caller methods should match this block only
*/
if (!inlines.isEmpty()) {
Pair<Executable, Callable<?>> pair = METHODS.get(0);
MethodDescriptor md = MethodGenerator.anyMatchDescriptor(
pair.first);
CompileCommand cc = new CompileCommand(Command.QUIET, md,
null, Scenario.Type.DIRECTIVE);
List<CompileCommand> commands = new ArrayList<>();
// Add appropriate "*.*" match block
commands.add(cc);
matchBlocks.put(md, commands);
// Add match block for this descriptor with inlines
dirFile.match(md);
writeInlines(dirFile);
dirFile.end();
}
if (!matchBlocks.isEmpty()) {
// terminates file
dirFile.end();
}
}
}
private State getState(Pair<Executable, Callable<?>> pair) {
State state = null;
MethodDescriptor execDesc = MethodGenerator.commandDescriptor(
pair.first);
boolean isMatchFound = false;
if (stateMap.containsKey(pair.first)) {
state = stateMap.get(pair.first);
}
for (MethodDescriptor matchDesc : matchBlocks.keySet()) {
if (execDesc.getCanonicalString().matches(matchDesc.getRegexp())) {
/*
* if executable matches regex
* then apply commands from this match to the state
*/
for (CompileCommand cc : matchBlocks.get(matchDesc)) {
if (state == null) {
state = new State();
}
if (!isMatchFound) {
// this is a first found match, apply all commands
state.apply(cc);
} else {
// apply only inline directives
switch (cc.command) {
case INLINE:
case DONTINLINE:
state.apply(cc);
break;
}
}
}
isMatchFound = true;
}
}
return state;
}
private void handleCommand(DirectiveWriter dirFile, CompileCommand cmd) {
Command command = cmd.command;
switch (command) {
case COMPILEONLY:
dirFile.excludeCompile(cmd.compiler, false);
break;
case EXCLUDE:
dirFile.excludeCompile(cmd.compiler, true);
break;
case QUIET:
/* there are no appropriate directive for this, just make
match be enabled */
case INLINE:
case DONTINLINE:
/* Inline commands will be written later.
Just make this match be enabled */
dirFile.emitCompiler(Scenario.Compiler.C1);
dirFile.option(DirectiveWriter.Option.ENABLE, true);
dirFile.end();
dirFile.emitCompiler(Scenario.Compiler.C2);
dirFile.option(DirectiveWriter.Option.ENABLE, true);
dirFile.end();
break;
case LOG:
dirFile.option(DirectiveWriter.Option.LOG, true);
break;
case PRINT:
dirFile.option(DirectiveWriter.Option.PRINT_ASSEMBLY, true);
break;
case NONEXISTENT:
dirFile.write(JSONFile.Element.PAIR, command.name);
dirFile.write(JSONFile.Element.OBJECT);
dirFile.write(JSONFile.Element.PAIR, command.name);
dirFile.write(JSONFile.Element.VALUE,
cmd.methodDescriptor.getString());
dirFile.end(); // ends object
break;
default:
throw new Error("TESTBUG: wrong command: " + command);
}
}
private void writeInlines(DirectiveWriter dirFile) {
List<String> c1Block = new ArrayList<>();
List<String> c2Block = new ArrayList<>();
List<String> allBlock = new ArrayList<>();
for (CompileCommand cc : inlines) {
String inlineMethodPattern;
switch (cc.command) {
case INLINE:
inlineMethodPattern = "+" + cc.methodDescriptor.getString();
break;
case DONTINLINE:
inlineMethodPattern = "-" + cc.methodDescriptor.getString();
break;
default:
throw new Error("TESTBUG: incorrect command got in "
+ "the list: " + cc.command);
}
if (cc.compiler == Scenario.Compiler.C1) {
c1Block.add(inlineMethodPattern);
} else if (cc.compiler == Scenario.Compiler.C2) {
c2Block.add(inlineMethodPattern);
} else {
allBlock.add(inlineMethodPattern);
}
}
dirFile.emitCompiler(Scenario.Compiler.C1);
if (!c1Block.isEmpty()) {
dirFile.inline(c1Block);
} else {
dirFile.option(DirectiveWriter.Option.ENABLE, true);
}
dirFile.end();
dirFile.emitCompiler(Scenario.Compiler.C2);
if (!c2Block.isEmpty()) {
dirFile.inline(c2Block);
} else {
dirFile.option(DirectiveWriter.Option.ENABLE, true);
}
dirFile.end();
if (!allBlock.isEmpty()) {
dirFile.inline(allBlock);
}
}
@Override
public void add(CompileCommand compileCommand) {
isFileValid &= compileCommand.isValid();
MethodDescriptor methodDescriptor = compileCommand.methodDescriptor;
switch (compileCommand.command) {
case INLINE:
case DONTINLINE:
inlines.add(compileCommand);
break;
}
for (MethodDescriptor md: matchBlocks.keySet()) {
if (methodDescriptor.getCanonicalString().matches(md.getRegexp())) {
matchBlocks.get(md).add(compileCommand);
}
}
if (!matchBlocks.containsKey(compileCommand.methodDescriptor)) {
List<CompileCommand> commands = new ArrayList<>();
commands.add(compileCommand);
matchBlocks.put(compileCommand.methodDescriptor, commands);
}
}
}