You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
398 lines
14 KiB
398 lines
14 KiB
/*
|
|
* @(#)Disassembler.java 2.1 2003/10/07
|
|
*
|
|
* Copyright (C) 1999, 2003 D.A. Watt and D.F. Brown
|
|
* Dept. of Computing Science, University of Glasgow, Glasgow G12 8QQ Scotland
|
|
* and School of Computer and Math Sciences, The Robert Gordon University,
|
|
* St. Andrew Street, Aberdeen AB25 1HG, Scotland.
|
|
* All rights reserved.
|
|
*
|
|
* This software is provided free for educational use only. It may
|
|
* not be used for commercial purposes without the prior written permission
|
|
* of the authors.
|
|
*/
|
|
|
|
package Triangle.AbstractMachine;
|
|
|
|
import java.io.DataInputStream;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.IOException;
|
|
|
|
/**
|
|
* Disassembles the TAM code in the given file, and displays the
|
|
* instructions on standard output.
|
|
*
|
|
* For example:
|
|
*
|
|
* <pre>
|
|
* java TAM.Disassembler obj.tam
|
|
* </pre>
|
|
*
|
|
* <p>
|
|
* Copyright 1991 David A. Watt, University of Glasgow<br>
|
|
* Copyright 1998 Deryck F. Brown, The Robert Gordon University<br>
|
|
* </p>
|
|
*
|
|
*/
|
|
|
|
public class Disassembler {
|
|
|
|
static String objectName;
|
|
|
|
static int CT;
|
|
|
|
/**
|
|
* Writes the r-field of an instruction in the form "l<I>reg</I>r", where
|
|
* l and r are the bracket characters to use.
|
|
*
|
|
* @param leftbracket the character to print before the register.
|
|
* @param r the number of the register.
|
|
* @param rightbracket the character to print after the register.
|
|
*/
|
|
private static void writeR(char leftbracket, int r, char rightbracket) {
|
|
|
|
System.out.print(leftbracket);
|
|
switch (r) {
|
|
case Machine.CBr:
|
|
System.out.print("CB");
|
|
break;
|
|
case Machine.CTr:
|
|
System.out.print("CT");
|
|
break;
|
|
case Machine.PBr:
|
|
System.out.print("PB");
|
|
break;
|
|
case Machine.PTr:
|
|
System.out.print("PT");
|
|
break;
|
|
case Machine.SBr:
|
|
System.out.print("SB");
|
|
break;
|
|
case Machine.STr:
|
|
System.out.print("ST");
|
|
break;
|
|
case Machine.HBr:
|
|
System.out.print("HB");
|
|
break;
|
|
case Machine.HTr:
|
|
System.out.print("HT");
|
|
break;
|
|
case Machine.LBr:
|
|
System.out.print("LB");
|
|
break;
|
|
case Machine.L1r:
|
|
System.out.print("L1");
|
|
break;
|
|
case Machine.L2r:
|
|
System.out.print("L2");
|
|
break;
|
|
case Machine.L3r:
|
|
System.out.print("L3");
|
|
break;
|
|
case Machine.L4r:
|
|
System.out.print("L4");
|
|
break;
|
|
case Machine.L5r:
|
|
System.out.print("L5");
|
|
break;
|
|
case Machine.L6r:
|
|
System.out.print("L6");
|
|
break;
|
|
case Machine.CPr:
|
|
System.out.print("CP");
|
|
break;
|
|
}
|
|
System.out.print(rightbracket);
|
|
}
|
|
|
|
/**
|
|
* Writes a void n-field of an instruction.
|
|
*/
|
|
private static void blankN() {
|
|
System.out.print(" ");
|
|
}
|
|
|
|
// Writes the n-field of an instruction.
|
|
/**
|
|
* Writes the n-field of an instruction in the form "(n)".
|
|
*
|
|
* @param n the integer to write.
|
|
*/
|
|
private static void writeN(int n) {
|
|
System.out.print("(" + n + ") ");
|
|
if (n < 10)
|
|
System.out.print(" ");
|
|
else if (n < 100)
|
|
System.out.print(" ");
|
|
}
|
|
|
|
/**
|
|
* Writes the d-field of an instruction.
|
|
*
|
|
* @param d the integer to write.
|
|
*/
|
|
private static void writeD(int d) {
|
|
System.out.print(d);
|
|
}
|
|
|
|
/**
|
|
* Writes the name of primitive routine with relative address d.
|
|
*
|
|
* @param d the displacment of the primitive routine.
|
|
*/
|
|
private static void writePrimitive(int d) {
|
|
switch (d) {
|
|
case Machine.idDisplacement:
|
|
System.out.print("id ");
|
|
break;
|
|
case Machine.notDisplacement:
|
|
System.out.print("not ");
|
|
break;
|
|
case Machine.andDisplacement:
|
|
System.out.print("and ");
|
|
break;
|
|
case Machine.orDisplacement:
|
|
System.out.print("or ");
|
|
break;
|
|
case Machine.succDisplacement:
|
|
System.out.print("succ ");
|
|
break;
|
|
case Machine.predDisplacement:
|
|
System.out.print("pred ");
|
|
break;
|
|
case Machine.negDisplacement:
|
|
System.out.print("neg ");
|
|
break;
|
|
case Machine.addDisplacement:
|
|
System.out.print("add ");
|
|
break;
|
|
case Machine.subDisplacement:
|
|
System.out.print("sub ");
|
|
break;
|
|
case Machine.multDisplacement:
|
|
System.out.print("mult ");
|
|
break;
|
|
case Machine.divDisplacement:
|
|
System.out.print("div ");
|
|
break;
|
|
case Machine.modDisplacement:
|
|
System.out.print("mod ");
|
|
break;
|
|
case Machine.ltDisplacement:
|
|
System.out.print("lt ");
|
|
break;
|
|
case Machine.leDisplacement:
|
|
System.out.print("le ");
|
|
break;
|
|
case Machine.geDisplacement:
|
|
System.out.print("ge ");
|
|
break;
|
|
case Machine.gtDisplacement:
|
|
System.out.print("gt ");
|
|
break;
|
|
case Machine.eqDisplacement:
|
|
System.out.print("eq ");
|
|
break;
|
|
case Machine.neDisplacement:
|
|
System.out.print("ne ");
|
|
break;
|
|
case Machine.eolDisplacement:
|
|
System.out.print("eol ");
|
|
break;
|
|
case Machine.eofDisplacement:
|
|
System.out.print("eof ");
|
|
break;
|
|
case Machine.getDisplacement:
|
|
System.out.print("get ");
|
|
break;
|
|
case Machine.putDisplacement:
|
|
System.out.print("put ");
|
|
break;
|
|
case Machine.geteolDisplacement:
|
|
System.out.print("geteol ");
|
|
break;
|
|
case Machine.puteolDisplacement:
|
|
System.out.print("puteol ");
|
|
break;
|
|
case Machine.getintDisplacement:
|
|
System.out.print("getint ");
|
|
break;
|
|
case Machine.putintDisplacement:
|
|
System.out.print("putint ");
|
|
break;
|
|
case Machine.newDisplacement:
|
|
System.out.print("new ");
|
|
break;
|
|
case Machine.disposeDisplacement:
|
|
System.out.print("dispose ");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Writes the given instruction in assembly-code format.
|
|
*
|
|
* @param instr the instruction to display.
|
|
*/
|
|
private static void writeInstruction(Instruction instr) {
|
|
|
|
switch (instr.op) {
|
|
case Machine.LOADop:
|
|
System.out.print("LOAD ");
|
|
writeN(instr.n);
|
|
writeD(instr.d);
|
|
writeR('[', instr.r, ']');
|
|
break;
|
|
|
|
case Machine.LOADAop:
|
|
System.out.print("LOADA ");
|
|
blankN();
|
|
writeD(instr.d);
|
|
writeR('[', instr.r, ']');
|
|
break;
|
|
|
|
case Machine.LOADIop:
|
|
System.out.print("LOADI ");
|
|
writeN(instr.n);
|
|
break;
|
|
|
|
case Machine.LOADLop:
|
|
System.out.print("LOADL ");
|
|
blankN();
|
|
writeD(instr.d);
|
|
break;
|
|
|
|
case Machine.STOREop:
|
|
System.out.print("STORE ");
|
|
writeN(instr.n);
|
|
writeD(instr.d);
|
|
writeR('[', instr.r, ']');
|
|
break;
|
|
|
|
case Machine.STOREIop:
|
|
System.out.print("STOREI");
|
|
writeN(instr.n);
|
|
break;
|
|
|
|
case Machine.CALLop:
|
|
System.out.print("CALL ");
|
|
if (instr.r == Machine.PBr) {
|
|
blankN();
|
|
writePrimitive(instr.d);
|
|
} else {
|
|
writeR('(', instr.n, ')');
|
|
System.out.print(" ");
|
|
writeD(instr.d);
|
|
writeR('[', instr.r, ']');
|
|
}
|
|
break;
|
|
|
|
case Machine.CALLIop:
|
|
System.out.print("CALLI ");
|
|
break;
|
|
|
|
case Machine.RETURNop:
|
|
System.out.print("RETURN");
|
|
writeN(instr.n);
|
|
writeD(instr.d);
|
|
break;
|
|
|
|
case Machine.PUSHop:
|
|
System.out.print("PUSH ");
|
|
blankN();
|
|
writeD(instr.d);
|
|
break;
|
|
|
|
case Machine.POPop:
|
|
System.out.print("POP ");
|
|
writeN(instr.n);
|
|
writeD(instr.d);
|
|
break;
|
|
|
|
case Machine.JUMPop:
|
|
System.out.print("JUMP ");
|
|
blankN();
|
|
writeD(instr.d);
|
|
writeR('[', instr.r, ']');
|
|
break;
|
|
|
|
case Machine.JUMPIop:
|
|
System.out.print("JUMPI ");
|
|
break;
|
|
|
|
case Machine.JUMPIFop:
|
|
System.out.print("JUMPIF");
|
|
writeN(instr.n);
|
|
writeD(instr.d);
|
|
writeR('[', instr.r, ']');
|
|
break;
|
|
|
|
case Machine.HALTop:
|
|
System.out.print("HALT ");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Writes all instructions of the program in code store.
|
|
*/
|
|
private static void disassembleProgram() {
|
|
for (int addr = Machine.CB; addr < CT; addr++) {
|
|
System.out.print(addr + ": ");
|
|
writeInstruction(Machine.code[addr]);
|
|
System.out.println();
|
|
}
|
|
}
|
|
|
|
// LOADING
|
|
|
|
/**
|
|
* Loads the TAM object program into code store from the named file.
|
|
*
|
|
* @param objectName the name of the file containing the program.
|
|
*/
|
|
static void loadObjectProgram(String objectName) {
|
|
|
|
FileInputStream objectFile = null;
|
|
DataInputStream objectStream = null;
|
|
|
|
int addr;
|
|
boolean finished = false;
|
|
|
|
try {
|
|
objectFile = new FileInputStream(objectName);
|
|
objectStream = new DataInputStream(objectFile);
|
|
|
|
addr = Machine.CB;
|
|
while (!finished) {
|
|
Machine.code[addr] = Instruction.read(objectStream);
|
|
if (Machine.code[addr] == null)
|
|
finished = true;
|
|
else
|
|
addr = addr + 1;
|
|
}
|
|
CT = addr;
|
|
objectFile.close();
|
|
} catch (FileNotFoundException s) {
|
|
CT = Machine.CB;
|
|
System.err.println("Error opening object file: " + s);
|
|
} catch (IOException s) {
|
|
CT = Machine.CB;
|
|
System.err.println("Error reading object file: " + s);
|
|
}
|
|
}
|
|
|
|
// DISASSEMBLE
|
|
|
|
public static void main(String[] args) {
|
|
System.out.println("********** TAM Disassembler (Sun Version 2.1) **********");
|
|
|
|
if (args.length == 1)
|
|
objectName = args[0];
|
|
else
|
|
objectName = "obj.tam";
|
|
|
|
loadObjectProgram(objectName);
|
|
disassembleProgram();
|
|
}
|
|
}
|
|
|