[Exspiminator-commits] CVS: exspiminator/base PowerPCAssembler.java,NONE,1.1 NewAssembler.java,1.5,1
Status: Alpha
Brought to you by:
nphillips
Menu
▾
▴
[Exspiminator-commits] CVS: exspiminator/base PowerPCAssembler.java,NONE,1.1 NewAssembler.java,1.5,1.6 InstructionEncoder.java,1.3,NONE PowerPCInstructionEncoder.java,1.4,NONE
|
From: Nigel P. <nph...@us...> - 2001-11-23 10:50:17
|
Update of /cvsroot/exspiminator/exspiminator/base
In directory usw-pr-cvs1:/tmp/cvs-serv24016/base
Modified Files:
NewAssembler.java
Added Files:
PowerPCAssembler.java
Removed Files:
InstructionEncoder.java PowerPCInstructionEncoder.java
Log Message:
Switch from InstructionEncoders to assembler subclasses.
--- NEW FILE ---
package exspiminator.base;
/** An assembler for the PowerPC instruction set.
BUG: allow the prefixes and force values to be set by the user!
*/
public class PowerPCAssembler extends NewAssembler
{
String gprPrefix;
String crfPrefix;
String crbPrefix;
int forceGprPrefix;
int forceCrfPrefix;
int forceCrbPrefix;
public PowerPCAssembler()
{
this(true);
}
public PowerPCAssembler(boolean allowSimplifiedMnemonics)
{
super(allowSimplifiedMnemonics
? SimplifiedPowerPCInstructionSet.getInstructionSet()
: PowerPCInstructionSet.getInstructionSet());
gprPrefix="r";
forceGprPrefix=WARN;
crfPrefix="cr";
forceCrfPrefix=WARN;
crbPrefix="crb";
forceCrbPrefix=WARN;
}
int parseGpr(String s) throws OperandFormatException
{
int result;
if (s.startsWith(gprPrefix))
{
result=parseInt(s.substring(gprPrefix.length()));
}
else
{
warn(forceGprPrefix, "Missing GPR prefix");
result=parseInt(s);
}
if (result<0 || result>31)
{
warn(ERROR, "GPR index out of bounds");
}
return result;
}
/** A wrapper around parseGpr which does not require the gprPrefix to be used when the value is zero, and
warns if it is present.*/
int parseA0(String s) throws OperandFormatException
{
int result;
try
{
result=Integer.parseInt(s);
if (result==0)
{
return result;
}
}
catch (NumberFormatException ex)
{
// fall through
}
int prefixed=parseGpr(s);
if (prefixed==0)
{
warn(WARN, "Register 0 specified where literal 0 will be coded");
}
return prefixed;
}
/** A wrapper around parseGpr which produces an error then the value is zero.*/
int parseANOT0(String s) throws OperandFormatException
{
int result=parseGpr(s);
if (result==0)
{
warn(ERROR, "Register 0 is invalid as a base register in the instruction");
}
return result;
}
int parseCrb(String s) throws OperandFormatException
{
int result;
if (s.startsWith(crbPrefix))
{
result=parseInt(s.substring(crbPrefix.length()));
}
else
{
warn(forceCrbPrefix, "Missing CRB prefix (" + crbPrefix + ")");
result=parseInt(s);
}
if (result<0 || result>31)
{
warn(ERROR, "CRB index out of bounds");
}
return result;
}
/** Could be optimized by insertXXX equivalents of PowerPCUtils.extractXXX stuff.
Could be generalized?*/
public int insertField(int opcode, int fieldID, String rawOperand) throws OperandFormatException
{
int operand;
switch (fieldID)
{
case PowerPCInstructionSet.A:
case PowerPCInstructionSet.B:
case PowerPCInstructionSet.D:
operand=parseGpr(rawOperand);
opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
is.getFieldLength(fieldID), operand);
return opcode;
case PowerPCInstructionSet.BD:
operand=resolveLabelOrInt(rawOperand);
if ((operand & 3) !=0)
{
warn(ERROR, "Unaligned branch target");
}
if (PowerPCUtils.extractAA(opcode)==0)
{
//System.err.println("Making address " + operand
// + " into displacement " + (operand-getCurrentAddress()));
operand-=getCurrentAddress();
}
if (operand>=Short.MIN_VALUE && operand<=Short.MAX_VALUE)
{
opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
is.getFieldLength(fieldID), operand/4);
}
else
{
warn(ERROR, "Branch conditional target out of bounds");
}
return opcode;
case PowerPCInstructionSet.CRFD:
case PowerPCInstructionSet.CRFS:
if (rawOperand.startsWith(crfPrefix))
{
operand=parseInt(rawOperand.substring(crfPrefix.length()));
}
else
{
warn(forceCrfPrefix, "Missing CRF prefix");
operand=parseInt(rawOperand);
}
if (operand>=0 && operand<=7)
{
opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
is.getFieldLength(fieldID), operand);
}
else
{
warn(ERROR, "CR index out of bounds");
}
return opcode;
case PowerPCInstructionSet.LI:
operand=resolveLabelOrInt(rawOperand);
if ((operand & 3) !=0)
{
warn(ERROR, "Unaligned branch displacement");
}
if (PowerPCUtils.extractAA(opcode)==0)
{
//System.err.println("Making address " + operand
// + " into displacement " + (operand-getCurrentAddress()));
operand-=getCurrentAddress();
}
if (operand<=(1<<24) && operand>=-1-(1<<24))
{
opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
is.getFieldLength(fieldID), operand/4);
}
else
{
warn(ERROR, "Branch target out of bounds");
}
return opcode;
case PowerPCInstructionSet.SIMM:
operand=resolveLabelOrInt(rawOperand);
if (operand>=Short.MIN_VALUE && operand<=Short.MAX_VALUE)
{
opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
is.getFieldLength(fieldID), operand);
}
else
{
warn(ERROR, "Signed immediate out of bounds");
}
return opcode;
case PowerPCInstructionSet.UIMM:
operand=resolveLabelOrInt(rawOperand);
if (operand>=0 && operand<(1<<16))
{
opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
is.getFieldLength(fieldID), operand);
}
else
{
warn(ERROR, "Unsigned immediate out of bounds");
}
return opcode;
case PowerPCInstructionSet.L:
operand=parseInt(rawOperand);
if (operand==0 || operand==1)
{
opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
is.getFieldLength(fieldID), operand);
return opcode;
}
else
{
warn(ERROR, "Invalid L bit");
}
case PowerPCInstructionSet.SH:
case PowerPCInstructionSet.MB:
case PowerPCInstructionSet.ME:
operand=parseInt(rawOperand);
if (operand>=0 && operand<=31)
{
opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
is.getFieldLength(fieldID), operand);
return opcode;
}
else
{
warn(ERROR, "Rotate operand out of bounds");
}
case PowerPCInstructionSet.SPR:
operand=parseInt(rawOperand);
if (operand==1 || operand==8 || operand==9)
{
// BUG: this ignores the other half of the field, which won't work when
// this is non-zero (i. e. for some of the other SPRs)
opcode|=operand<<16;
//opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
// is.getFieldLength(fieldID)/2, operand);
return opcode;
}
else
{
warn(ERROR, "Unknown SPR");
}
case PowerPCInstructionSet.CRM:
operand=parseInt(rawOperand);
if (operand>=0 && operand<=0xFF)
{
opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
is.getFieldLength(fieldID), operand);
return opcode;
}
else
{
warn(ERROR, "Invalid condition register mask");
}
case PowerPCInstructionSet.BI:
operand=parseInt(rawOperand);
if (operand>=0 && operand<=31)
{
opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
is.getFieldLength(fieldID), operand);
return opcode;
}
else
{
warn(ERROR, "Invalid condition register bit index in branch condition");
}
case PowerPCInstructionSet.BO:
operand=parseInt(rawOperand);
// BUG: could be more exclusive than this?
if (operand>=0 && operand<=31)
{
opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
is.getFieldLength(fieldID), operand);
return opcode;
}
else
{
warn(ERROR, "Invalid branch condition option");
}
case PowerPCInstructionSet.A0:
operand=parseA0(rawOperand);
opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
is.getFieldLength(fieldID), operand);
return opcode;
case PowerPCInstructionSet.ANOT0:
operand=parseANOT0(rawOperand);
opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
is.getFieldLength(fieldID), operand);
return opcode;
case PowerPCInstructionSet.CRBA:
case PowerPCInstructionSet.CRBB:
case PowerPCInstructionSet.CRBD:
operand=parseCrb(rawOperand);
opcode=Utils.setField(opcode, is.getFieldStart(fieldID),
is.getFieldLength(fieldID), operand);
return opcode;
// simplified mnemonics
// some are handled via recursion to ensure the same verification - in which case
// the operand needs to be converted back to a string after manipulation
// [optimize? - could use a instance stringbuffer], including any prefix etc
// some are done manually for simplicity
// BUG: check all prefixes done properly: may have to do more than ""+operand to
// overcome warning as r is required for regs etc.
case SimplifiedPowerPCInstructionSet.NEGSIMM:
operand=parseInt(rawOperand);
return insertField(opcode, PowerPCInstructionSet.SIMM, ""+(-operand));
case SimplifiedPowerPCInstructionSet.DAB:
operand=parseGpr(rawOperand);
opcode=Utils.setField(opcode, is.getFieldStart(PowerPCInstructionSet.D),
is.getFieldLength(PowerPCInstructionSet.D), operand);
opcode=Utils.setField(opcode, is.getFieldStart(PowerPCInstructionSet.A),
is.getFieldLength(PowerPCInstructionSet.A), operand);
opcode=Utils.setField(opcode, is.getFieldStart(PowerPCInstructionSet.B),
is.getFieldLength(PowerPCInstructionSet.B), operand);
return opcode;
case SimplifiedPowerPCInstructionSet.AB:
operand=parseGpr(rawOperand);
opcode=Utils.setField(opcode, is.getFieldStart(PowerPCInstructionSet.A),
is.getFieldLength(PowerPCInstructionSet.A), operand);
opcode=Utils.setField(opcode, is.getFieldStart(PowerPCInstructionSet.B),
is.getFieldLength(PowerPCInstructionSet.B), operand);
return opcode;
case SimplifiedPowerPCInstructionSet.DB:
operand=parseGpr(rawOperand);
opcode=Utils.setField(opcode, is.getFieldStart(PowerPCInstructionSet.D),
is.getFieldLength(PowerPCInstructionSet.D), operand);
opcode=Utils.setField(opcode, is.getFieldStart(PowerPCInstructionSet.B),
is.getFieldLength(PowerPCInstructionSet.B), operand);
return opcode;
case SimplifiedPowerPCInstructionSet.ME_PLUS_1:
operand=parseInt(rawOperand);
return insertField(opcode, PowerPCInstructionSet.ME, ""+(operand-1));
case SimplifiedPowerPCInstructionSet.THIRTY_TWO_MINUS_MB:
operand=parseInt(rawOperand);
return insertField(opcode, PowerPCInstructionSet.MB, ""+(32-operand));
case SimplifiedPowerPCInstructionSet.COMPLETE1:
{
operand=parseInt(rawOperand);
int n=32-PowerPCUtils.extractMB(opcode);
return insertField(opcode, PowerPCInstructionSet.SH, ""+(operand+n));
}
case SimplifiedPowerPCInstructionSet.TEMP_ME:
operand=parseInt(rawOperand);
return insertField(opcode, PowerPCInstructionSet.ME, ""+operand);
case SimplifiedPowerPCInstructionSet.COMPLETE2:
{
operand=parseInt(rawOperand);
opcode=insertField(opcode, PowerPCInstructionSet.MB, ""+operand);
opcode=insertField(opcode, PowerPCInstructionSet.SH, ""+(32-operand));
int n=PowerPCUtils.extractME(opcode);
opcode&=~0x3E; // remove old ME
return insertField(opcode, PowerPCInstructionSet.ME, ""+(operand+n-1));
}
case SimplifiedPowerPCInstructionSet.COMPLETE3:
{
operand=parseInt(rawOperand);
opcode=insertField(opcode, PowerPCInstructionSet.MB, ""+operand);
int n=PowerPCUtils.extractME(opcode);
opcode=insertField(opcode, PowerPCInstructionSet.SH, ""+(32-(operand+n)));
opcode&=~0x3E; // remove old ME
return insertField(opcode, PowerPCInstructionSet.ME, ""+(operand+n-1));
}
case SimplifiedPowerPCInstructionSet.THIRTY_TWO_MINUS_SH:
operand=parseInt(rawOperand);
return insertField(opcode, PowerPCInstructionSet.SH, ""+(32-operand));
case SimplifiedPowerPCInstructionSet.SH_AND_31_MINUS_ME:
operand=parseInt(rawOperand);
return insertField(
insertField(opcode, PowerPCInstructionSet.SH, ""+operand),
PowerPCInstructionSet.ME, ""+(31-operand));
case SimplifiedPowerPCInstructionSet.MB_AND_32_MINUS_SH:
operand=parseInt(rawOperand);
return insertField(
insertField(opcode, PowerPCInstructionSet.MB, ""+operand),
PowerPCInstructionSet.SH, ""+(32-operand));
case SimplifiedPowerPCInstructionSet.THIRTY_ONE_MINUS_ME:
operand=parseInt(rawOperand);
return insertField(opcode, PowerPCInstructionSet.ME, ""+(31-operand));
case SimplifiedPowerPCInstructionSet.COMPLETE4:
{
operand=parseInt(rawOperand);
opcode=insertField(opcode, PowerPCInstructionSet.SH, ""+operand);
int b=PowerPCUtils.extractME(opcode);
opcode&=~0x3E; // remove old ME
opcode=insertField(opcode, PowerPCInstructionSet.MB, ""+(b-operand));
return insertField(opcode, PowerPCInstructionSet.ME, ""+(31-operand));
}
case SimplifiedPowerPCInstructionSet.CRBAB:
operand=parseCrb(rawOperand);
opcode=Utils.setField(opcode, is.getFieldStart(PowerPCInstructionSet.CRBA),
is.getFieldLength(PowerPCInstructionSet.CRBA), operand);
opcode=Utils.setField(opcode, is.getFieldStart(PowerPCInstructionSet.CRBB),
is.getFieldLength(PowerPCInstructionSet.CRBB), operand);
return opcode;
case SimplifiedPowerPCInstructionSet.CRBDAB:
operand=parseCrb(rawOperand);
opcode=Utils.setField(opcode, is.getFieldStart(PowerPCInstructionSet.CRBD),
is.getFieldLength(PowerPCInstructionSet.CRBD), operand);
opcode=Utils.setField(opcode, is.getFieldStart(PowerPCInstructionSet.CRBA),
is.getFieldLength(PowerPCInstructionSet.CRBA), operand);
opcode=Utils.setField(opcode, is.getFieldStart(PowerPCInstructionSet.CRBB),
is.getFieldLength(PowerPCInstructionSet.CRBB), operand);
return opcode;
default:
throw new OperandFormatException("Internal error: Unknown instruction field ("
+ fieldID + ").");
}
}
}
Index: NewAssembler.java
===================================================================
RCS file: /cvsroot/exspiminator/exspiminator/base/NewAssembler.java,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -r1.5 -r1.6
*** NewAssembler.java 2001/11/22 12:01:07 1.5
--- NewAssembler.java 2001/11/23 10:50:14 1.6
***************
*** 4,46 ****
import java.util.*;
! /** Brand new assembler, fixing most of the design defects of the previous one.
! This version is a single-pass assembler, using back-patches for forward references.
! To do:
! + move "rA"->"A" and "crB"->"B" handling to PowerPCInstructionEncoder
! + check instruction set coding for errors that will cause problems with above (i.e. different types sharing a field ID)
! + e.g. A0... this will probably need going over line by line.
! - check disp(rX) handling
! - allow stuff like "bdnzt eq, target" i.e. make cr bit index aliases - but how to do other crfs "bdnzt 4*cr5+eq, target"?
! (see prog-env appendix F)
! + implement the back-patching required for a single pass assembler (or hook up Preprocessor)
! - write .align, .byte, .double, .float, .long, .llong, .quad (?), .set (?), .short, .space, .string, .vbyte (?)
! - hook it all up to the gui and test
! + remove old assembler stuff that's no longer used (Assembler, Assembling prefs, Glue, PowerPCAssemblingPrefs, Preprocessor (?)
! - document (inc release notes?)
! - release!
*/
! public class NewAssembler
{
! static final String LONG=".long", BYTE=".byte", ALIGN=".align", SPACE=".space", SHORT=".short", SET=".set";
! static final String[] directives={LONG, BYTE, ALIGN, SPACE, SHORT, SET};
/** Warning levels.*/
! static final int IGNORE=0, WARN=1, ERROR=2;
! InstructionSet is;
! Map instructions;
! InstructionEncoder encoder;
! int currentLineNum;
! int currentAddress;
! Map labelTable;
! Parser parser;
! StringBuffer warnings;
! Map aliases;
public NewAssembler(InstructionSet is)
{
this.is=is;
- // BUG: not generic!
- this.encoder=new PowerPCInstructionEncoder(this);
instructions=new HashMap(is.instructions.size()*2);
aliases=new HashMap();
--- 4,42 ----
import java.util.*;
! /** Brand new assembler, fixing most of the design defects of the previous one. This version
! is a single-pass assembler, using back-patches for forward references. This class contains
! the instruction set neutral code. Instruction set specific functionality is to be handled in
! subclasses. Note that the method <code>insertField(int, int, String)</code> is assumed to be
! inherently platform specific and is therefore abstract.
! <p>To do:
! <ul>
! <li>check/fix disp(rX) handling
! <li>allow stuff like "bdnzt eq, target" i.e. make cr bit index aliases - but how to do other
! crfs "bdnzt 4*cr5+eq, target"? (see prog-env appendix F)
! <li>write .double, .float, .llong, .quad (?), .string, .vbyte (?)
! </ul>
! @see #insertField(int, int, String)
*/
! public abstract class NewAssembler
{
! protected static final String LONG=".long", BYTE=".byte", ALIGN=".align",
! SPACE=".space", SHORT=".short", SET=".set";
! protected static final String[] directives={LONG, BYTE, ALIGN, SPACE, SHORT, SET};
/** Warning levels.*/
! protected static final int IGNORE=0, WARN=1, ERROR=2;
! protected InstructionSet is;
! protected Map instructions;
! protected int currentLineNum;
! protected int currentAddress;
! protected Map labelTable;
! protected Parser parser;
! protected StringBuffer warnings;
! protected Map aliases;
public NewAssembler(InstructionSet is)
{
this.is=is;
instructions=new HashMap(is.instructions.size()*2);
aliases=new HashMap();
***************
*** 53,72 ****
}
! int getCurrentAddress()
{
return currentAddress;
}
! int getCurrentLineNum()
{
return currentLineNum;
}
! Integer resolveLabel(String label)
{
return (Integer) labelTable.get(label);
}
! int parseInt(String s) throws OperandFormatException
{
try
--- 49,68 ----
}
! protected int getCurrentAddress()
{
return currentAddress;
}
! protected int getCurrentLineNum()
{
return currentLineNum;
}
! protected Integer resolveLabel(String label)
{
return (Integer) labelTable.get(label);
}
! protected int parseInt(String s) throws OperandFormatException
{
try
***************
*** 83,87 ****
/** This performs the label substitution or literal parsing for branch targets.
Also used to allow things like <code>li rA, label</code> and <code>la rA, label(rB)</code>.*/
! int resolveLabelOrInt(String target) throws OperandFormatException
{
int result;
--- 79,83 ----
/** This performs the label substitution or literal parsing for branch targets.
Also used to allow things like <code>li rA, label</code> and <code>la rA, label(rB)</code>.*/
! protected int resolveLabelOrInt(String target) throws OperandFormatException
{
int result;
***************
*** 106,110 ****
}
! void warn(int option, String message) throws OperandFormatException
{
if (option==1)
--- 102,106 ----
}
! protected void warn(int option, String message) throws OperandFormatException
{
if (option==1)
***************
*** 129,138 ****
}
! /** allow differentiating by both mnemonic and num operands
! Bug: change to offer different versions of it depending on number of operands.
! May involve name mangling... or not: could do it properly and make a comparitor
! that returns a value based on the string comparison unless they match in which
case it also compares the number of operands.*/
! InstructionType lookupInstructionType(String mnemonic, int numOperands) throws AssemblerException
{
//List matchingByMnemonics=someLookupMagic(mnemonic);
--- 125,136 ----
}
! /** The signature of this method suggests that InstructionTypes need be unique with regard to both
! mnemonic and num operands, i.e. that different types with the same mnemonic are allowed provided
! they differ in their number of operands. Currently, this is not yet implemented, so InstructionTypes
! must have a unique mnemonic. This is a BUG in that the feature is used for the simplified PowerPC
! instructions. The fix may involve name mangling, but may not: we could do it properly and make a
! comparitor that returns a value based on the string comparison unless they match in which
case it also compares the number of operands.*/
! protected InstructionType lookupInstructionType(String mnemonic, int numOperands) throws AssemblerException
{
//List matchingByMnemonics=someLookupMagic(mnemonic);
***************
*** 156,160 ****
/** Returns the string matching the given string iff it is contained in the directives array.
Just uses a linear search: the list of possible directives is short.*/
! String lookupDirective(String directive)
{
for (int i=0; i<directives.length; i++)
--- 154,158 ----
/** Returns the string matching the given string iff it is contained in the directives array.
Just uses a linear search: the list of possible directives is short.*/
! protected String lookupDirective(String directive)
{
for (int i=0; i<directives.length; i++)
***************
*** 169,173 ****
/** Returns the aliased value if the argument has been set as an alias, otherwise it returns the argument.*/
! String replaceAliases(String s)
{
String r=(String) aliases.get(s);
--- 167,171 ----
/** Returns the aliased value if the argument has been set as an alias, otherwise it returns the argument.*/
! protected String replaceAliases(String s)
{
String r=(String) aliases.get(s);
***************
*** 176,183 ****
! /** Returns true if the string is empty, the first character is a digit, or it's
! a mnemonic in the current instruction set (since that would mess up our crappy address
! calculation) or if it contains a colon (it's just too confusing for the user).
! Note duplicate labels are handled elsewhere.
ISSUE: May require other checks too?*/
public boolean isIllegalLabel(String s)
--- 174,179 ----
! /** Returns true if the string is empty, the first character is a digit, or it's a mnemonic in the current
! instruction set or contains a colon (it's just too confusing). Note duplicate labels are handled elsewhere.
ISSUE: May require other checks too?*/
public boolean isIllegalLabel(String s)
***************
*** 190,194 ****
@param incompletes A list to which to add a list of AssemblyLines producing an UnknownSymbolException.
If this vlaue if null, a new AssemblerException will be thrown.*/
! void assembleLine(Line line, DataOutput output, List incompletes, int lineNum)
throws AssemblerException, IOException
{
--- 186,190 ----
@param incompletes A list to which to add a list of AssemblyLines producing an UnknownSymbolException.
If this vlaue if null, a new AssemblerException will be thrown.*/
! protected void assembleLine(Line line, DataOutput output, List incompletes, int lineNum)
throws AssemblerException, IOException
{
***************
*** 218,222 ****
for (int i=0; i<it.getNumOperands(); i++)
{
! opcode=encoder.insertField(opcode, it.getOperandField(i),
replaceAliases(line.getOperand(i)));
//System.err.println("Inserting operand " + i + " which is " + line.getOperand(i));
--- 214,218 ----
for (int i=0; i<it.getNumOperands(); i++)
{
! opcode=insertField(opcode, it.getOperandField(i),
replaceAliases(line.getOperand(i)));
//System.err.println("Inserting operand " + i + " which is " + line.getOperand(i));
***************
*** 330,333 ****
--- 326,336 ----
}
+ /** Updates an opcode with a given value inserted into the given field.
+ @param opcode The instruction as it currently is.
+ @param fieldID The identifier of the field, as given by the instruction type data.
+ @param operand The value to be encoded and inserted into the opcode.
+ @return The updated opcode.*/
+ public abstract int insertField(int opcode, int fieldID, String operand) throws OperandFormatException;
+
public byte[] assemble(String s) throws AssemblerException
{
***************
*** 374,378 ****
}
! byte[] backpatch(byte[] data, List incompletes) throws AssemblerException, IOException
{
RandomAccessDataOutput output=new RandomAccessDataOutput(data);
--- 377,381 ----
}
! protected byte[] backpatch(byte[] data, List incompletes) throws AssemblerException, IOException
{
RandomAccessDataOutput output=new RandomAccessDataOutput(data);
--- InstructionEncoder.java DELETED ---
--- PowerPCInstructionEncoder.java DELETED ---
|
