| /* |
| * Copyright (c) 2009, 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 org.graalvm.compiler.code; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.OutputStream; |
| import java.io.PrintStream; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.TreeMap; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import org.graalvm.compiler.code.CompilationResult.CodeAnnotation; |
| import org.graalvm.compiler.code.CompilationResult.CodeComment; |
| import org.graalvm.compiler.code.CompilationResult.JumpTable; |
| |
| import jdk.vm.ci.code.CodeUtil; |
| |
| /** |
| * A HexCodeFile is a textual format for representing a chunk of machine code along with extra |
| * information that can be used to enhance a disassembly of the code. |
| * |
| * A pseudo grammar for a HexCodeFile is given below. |
| * |
| * <pre> |
| * HexCodeFile ::= Platform Delim HexCode Delim (OptionalSection Delim)* |
| * |
| * OptionalSection ::= Comment | OperandComment | JumpTable | LookupTable |
| * |
| * Platform ::= "Platform" ISA WordWidth |
| * |
| * HexCode ::= "HexCode" StartAddress HexDigits |
| * |
| * Comment ::= "Comment" Position String |
| * |
| * OperandComment ::= "OperandComment" Position String |
| * |
| * JumpTable ::= "JumpTable" Position EntrySize Low High |
| * |
| * LookupTable ::= "LookupTable" Position NPairs KeySize OffsetSize |
| * |
| * Position, EntrySize, Low, High, NPairs KeySize OffsetSize ::= int |
| * |
| * Delim := "<||@" |
| * </pre> |
| * |
| * There must be exactly one HexCode and Platform part in a HexCodeFile. The length of HexDigits |
| * must be even as each pair of digits represents a single byte. |
| * <p> |
| * Below is an example of a valid Code input: |
| * |
| * <pre> |
| * |
| * Platform AMD64 64 <||@ |
| * HexCode 0 e8000000009090904883ec084889842410d0ffff48893c24e800000000488b3c24488bf0e8000000004883c408c3 <||@ |
| * Comment 24 frame-ref-map: +0 {0} |
| * at java.lang.String.toLowerCase(String.java:2496) [bci: 1] |
| * |0 |
| * locals: |stack:0:a |
| * stack: |stack:0:a |
| * <||@ |
| * OperandComment 24 {java.util.Locale.getDefault()} <||@ |
| * Comment 36 frame-ref-map: +0 {0} |
| * at java.lang.String.toLowerCase(String.java:2496) [bci: 4] |
| * |0 |
| * locals: |stack:0:a |
| * <||@ |
| * OperandComment 36 {java.lang.String.toLowerCase(Locale)} lt;||@ |
| * |
| * </pre> |
| */ |
| public class HexCodeFile { |
| |
| public static final String NEW_LINE = CodeUtil.NEW_LINE; |
| public static final String SECTION_DELIM = " <||@"; |
| public static final String COLUMN_END = " <|@"; |
| public static final Pattern SECTION = Pattern.compile("(\\S+)\\s+(.*)", Pattern.DOTALL); |
| public static final Pattern COMMENT = Pattern.compile("(\\d+)\\s+(.*)", Pattern.DOTALL); |
| public static final Pattern OPERAND_COMMENT = COMMENT; |
| public static final Pattern JUMP_TABLE = Pattern.compile("(\\d+)\\s+(\\d+)\\s+(-{0,1}\\d+)\\s+(-{0,1}\\d+)\\s*"); |
| public static final Pattern LOOKUP_TABLE = Pattern.compile("(\\d+)\\s+(\\d+)\\s+(\\d+)\\s+(\\d+)\\s*"); |
| public static final Pattern HEX_CODE = Pattern.compile("(\\p{XDigit}+)(?:\\s+(\\p{XDigit}*))?"); |
| public static final Pattern PLATFORM = Pattern.compile("(\\S+)\\s+(\\S+)", Pattern.DOTALL); |
| |
| /** |
| * Delimiter placed before a HexCodeFile when embedded in a string/stream. |
| */ |
| public static final String EMBEDDED_HCF_OPEN = "<<<HexCodeFile"; |
| |
| /** |
| * Delimiter placed after a HexCodeFile when embedded in a string/stream. |
| */ |
| public static final String EMBEDDED_HCF_CLOSE = "HexCodeFile>>>"; |
| |
| /** |
| * Map from a machine code position to a list of comments for the position. |
| */ |
| public final Map<Integer, List<String>> comments = new TreeMap<>(); |
| |
| /** |
| * Map from a machine code position to a comment for the operands of the instruction at the |
| * position. |
| */ |
| public final Map<Integer, List<String>> operandComments = new TreeMap<>(); |
| |
| public final byte[] code; |
| |
| public final ArrayList<JumpTable> jumpTables = new ArrayList<>(); |
| |
| public final String isa; |
| |
| public final int wordWidth; |
| |
| public final long startAddress; |
| |
| public HexCodeFile(byte[] code, long startAddress, String isa, int wordWidth) { |
| this.code = code; |
| this.startAddress = startAddress; |
| this.isa = isa; |
| this.wordWidth = wordWidth; |
| } |
| |
| /** |
| * Parses a string in the format produced by {@link #toString()} to produce a |
| * {@link HexCodeFile} object. |
| */ |
| public static HexCodeFile parse(String input, int sourceOffset, String source, String sourceName) { |
| return new Parser(input, sourceOffset, source, sourceName).hcf; |
| } |
| |
| /** |
| * Formats this HexCodeFile as a string that can be parsed with |
| * {@link #parse(String, int, String, String)}. |
| */ |
| @Override |
| public String toString() { |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| writeTo(baos); |
| return baos.toString(); |
| } |
| |
| public String toEmbeddedString() { |
| return EMBEDDED_HCF_OPEN + NEW_LINE + toString() + EMBEDDED_HCF_CLOSE; |
| } |
| |
| public void writeTo(OutputStream out) { |
| PrintStream ps = out instanceof PrintStream ? (PrintStream) out : new PrintStream(out); |
| ps.printf("Platform %s %d %s%n", isa, wordWidth, SECTION_DELIM); |
| ps.printf("HexCode %x %s %s%n", startAddress, HexCodeFile.hexCodeString(code), SECTION_DELIM); |
| |
| for (JumpTable table : jumpTables) { |
| ps.printf("JumpTable %d %d %d %d %s%n", table.position, table.entrySize, table.low, table.high, SECTION_DELIM); |
| } |
| |
| for (Map.Entry<Integer, List<String>> e : comments.entrySet()) { |
| int pos = e.getKey(); |
| for (String comment : e.getValue()) { |
| ps.printf("Comment %d %s %s%n", pos, comment, SECTION_DELIM); |
| } |
| } |
| |
| for (Map.Entry<Integer, List<String>> e : operandComments.entrySet()) { |
| for (String c : e.getValue()) { |
| ps.printf("OperandComment %d %s %s%n", e.getKey(), c, SECTION_DELIM); |
| } |
| } |
| ps.flush(); |
| } |
| |
| /** |
| * Formats a byte array as a string of hex digits. |
| */ |
| public static String hexCodeString(byte[] code) { |
| if (code == null) { |
| return ""; |
| } else { |
| StringBuilder sb = new StringBuilder(code.length * 2); |
| for (int b : code) { |
| String hex = Integer.toHexString(b & 0xff); |
| if (hex.length() == 1) { |
| sb.append('0'); |
| } |
| sb.append(hex); |
| } |
| return sb.toString(); |
| } |
| } |
| |
| /** |
| * Adds a comment to the list of comments for a given position. |
| */ |
| public void addComment(int pos, String comment) { |
| List<String> list = comments.get(pos); |
| if (list == null) { |
| list = new ArrayList<>(); |
| comments.put(pos, list); |
| } |
| list.add(encodeString(comment)); |
| } |
| |
| /** |
| * Adds an operand comment for a given position. |
| */ |
| public void addOperandComment(int pos, String comment) { |
| List<String> list = comments.get(pos); |
| if (list == null) { |
| list = new ArrayList<>(1); |
| comments.put(pos, list); |
| } |
| list.add(encodeString(comment)); |
| } |
| |
| /** |
| * Adds any jump tables, lookup tables or code comments from a list of code annotations. |
| */ |
| public static void addAnnotations(HexCodeFile hcf, List<CodeAnnotation> annotations) { |
| if (annotations == null || annotations.isEmpty()) { |
| return; |
| } |
| for (CodeAnnotation a : annotations) { |
| if (a instanceof JumpTable) { |
| JumpTable table = (JumpTable) a; |
| hcf.jumpTables.add(table); |
| } else if (a instanceof CodeComment) { |
| CodeComment comment = (CodeComment) a; |
| hcf.addComment(comment.position, comment.value); |
| } |
| } |
| } |
| |
| /** |
| * Modifies a string to mangle any substrings matching {@link #SECTION_DELIM} and |
| * {@link #COLUMN_END}. |
| */ |
| public static String encodeString(String input) { |
| int index; |
| String s = input; |
| while ((index = s.indexOf(SECTION_DELIM)) != -1) { |
| s = s.substring(0, index) + " < |@" + s.substring(index + SECTION_DELIM.length()); |
| } |
| while ((index = s.indexOf(COLUMN_END)) != -1) { |
| s = s.substring(0, index) + " < @" + s.substring(index + COLUMN_END.length()); |
| } |
| return s; |
| } |
| |
| /** |
| * Helper class to parse a string in the format produced by {@link HexCodeFile#toString()} and |
| * produce a {@link HexCodeFile} object. |
| */ |
| static class Parser { |
| |
| final String input; |
| final String inputSource; |
| String isa; |
| int wordWidth; |
| byte[] code; |
| long startAddress; |
| HexCodeFile hcf; |
| |
| Parser(String input, int sourceOffset, String source, String sourceName) { |
| this.input = input; |
| this.inputSource = sourceName; |
| parseSections(sourceOffset, source); |
| } |
| |
| void makeHCF() { |
| if (hcf == null) { |
| if (isa != null && wordWidth != 0 && code != null) { |
| hcf = new HexCodeFile(code, startAddress, isa, wordWidth); |
| } |
| } |
| } |
| |
| void checkHCF(String section, int offset) { |
| check(hcf != null, offset, section + " section must be after Platform and HexCode section"); |
| } |
| |
| void check(boolean condition, int offset, String message) { |
| if (!condition) { |
| error(offset, message); |
| } |
| } |
| |
| Error error(int offset, String message) { |
| throw new Error(errorMessage(offset, message)); |
| } |
| |
| void warning(int offset, String message) { |
| PrintStream err = System.err; |
| err.println("Warning: " + errorMessage(offset, message)); |
| } |
| |
| String errorMessage(int offset, String message) { |
| assert offset < input.length(); |
| InputPos inputPos = filePos(offset); |
| int lineEnd = input.indexOf(HexCodeFile.NEW_LINE, offset); |
| int lineStart = offset - inputPos.col; |
| String line = lineEnd == -1 ? input.substring(lineStart) : input.substring(lineStart, lineEnd); |
| return String.format("%s:%d: %s%n%s%n%" + (inputPos.col + 1) + "s", inputSource, inputPos.line, message, line, "^"); |
| } |
| |
| static class InputPos { |
| |
| final int line; |
| final int col; |
| |
| InputPos(int line, int col) { |
| this.line = line; |
| this.col = col; |
| } |
| } |
| |
| InputPos filePos(int index) { |
| assert input != null; |
| int lineStart = input.lastIndexOf(HexCodeFile.NEW_LINE, index) + 1; |
| |
| String l = input.substring(lineStart, lineStart + 10); |
| PrintStream out = System.out; |
| out.println("YYY" + input.substring(index, index + 10) + "..."); |
| out.println("XXX" + l + "..."); |
| |
| int pos = input.indexOf(HexCodeFile.NEW_LINE, 0); |
| int line = 1; |
| while (pos > 0 && pos < index) { |
| line++; |
| pos = input.indexOf(HexCodeFile.NEW_LINE, pos + 1); |
| } |
| return new InputPos(line, index - lineStart); |
| } |
| |
| void parseSections(int offset, String source) { |
| assert input.startsWith(source, offset); |
| int index = 0; |
| int endIndex = source.indexOf(SECTION_DELIM); |
| while (endIndex != -1) { |
| while (source.charAt(index) <= ' ') { |
| index++; |
| } |
| String section = source.substring(index, endIndex).trim(); |
| parseSection(offset + index, section); |
| index = endIndex + SECTION_DELIM.length(); |
| endIndex = source.indexOf(SECTION_DELIM, index); |
| } |
| } |
| |
| int parseInt(int offset, String value) { |
| try { |
| return Integer.parseInt(value); |
| } catch (NumberFormatException e) { |
| throw error(offset, "Not a valid integer: " + value); |
| } |
| } |
| |
| void parseSection(int offset, String section) { |
| if (section.isEmpty()) { |
| return; |
| } |
| assert input.startsWith(section, offset); |
| Matcher m = HexCodeFile.SECTION.matcher(section); |
| check(m.matches(), offset, "Section does not match pattern " + HexCodeFile.SECTION); |
| |
| String header = m.group(1); |
| String body = m.group(2); |
| int headerOffset = offset + m.start(1); |
| int bodyOffset = offset + m.start(2); |
| |
| if (header.equals("Platform")) { |
| check(isa == null, bodyOffset, "Duplicate Platform section found"); |
| m = HexCodeFile.PLATFORM.matcher(body); |
| check(m.matches(), bodyOffset, "Platform does not match pattern " + HexCodeFile.PLATFORM); |
| isa = m.group(1); |
| wordWidth = parseInt(bodyOffset + m.start(2), m.group(2)); |
| makeHCF(); |
| } else if (header.equals("HexCode")) { |
| check(code == null, bodyOffset, "Duplicate Code section found"); |
| m = HexCodeFile.HEX_CODE.matcher(body); |
| check(m.matches(), bodyOffset, "Code does not match pattern " + HexCodeFile.HEX_CODE); |
| String hexAddress = m.group(1); |
| startAddress = Long.valueOf(hexAddress, 16); |
| String hexCode = m.group(2); |
| if (hexCode == null) { |
| code = new byte[0]; |
| } else { |
| check((hexCode.length() % 2) == 0, bodyOffset, "Hex code length must be even"); |
| code = new byte[hexCode.length() / 2]; |
| for (int i = 0; i < code.length; i++) { |
| String hexByte = hexCode.substring(i * 2, (i + 1) * 2); |
| code[i] = (byte) Integer.parseInt(hexByte, 16); |
| } |
| } |
| makeHCF(); |
| } else if (header.equals("Comment")) { |
| checkHCF("Comment", headerOffset); |
| m = HexCodeFile.COMMENT.matcher(body); |
| check(m.matches(), bodyOffset, "Comment does not match pattern " + HexCodeFile.COMMENT); |
| int pos = parseInt(bodyOffset + m.start(1), m.group(1)); |
| String comment = m.group(2); |
| hcf.addComment(pos, comment); |
| } else if (header.equals("OperandComment")) { |
| checkHCF("OperandComment", headerOffset); |
| m = HexCodeFile.OPERAND_COMMENT.matcher(body); |
| check(m.matches(), bodyOffset, "OperandComment does not match pattern " + HexCodeFile.OPERAND_COMMENT); |
| int pos = parseInt(bodyOffset + m.start(1), m.group(1)); |
| String comment = m.group(2); |
| hcf.addOperandComment(pos, comment); |
| } else if (header.equals("JumpTable")) { |
| checkHCF("JumpTable", headerOffset); |
| m = HexCodeFile.JUMP_TABLE.matcher(body); |
| check(m.matches(), bodyOffset, "JumpTable does not match pattern " + HexCodeFile.JUMP_TABLE); |
| int pos = parseInt(bodyOffset + m.start(1), m.group(1)); |
| int entrySize = parseInt(bodyOffset + m.start(2), m.group(2)); |
| int low = parseInt(bodyOffset + m.start(3), m.group(3)); |
| int high = parseInt(bodyOffset + m.start(4), m.group(4)); |
| hcf.jumpTables.add(new JumpTable(pos, low, high, entrySize)); |
| } else { |
| error(offset, "Unknown section header: " + header); |
| } |
| } |
| } |
| } |
