/**
* Given an IA32 opcode, return the set of opt compiler IA32_ operators that translate to it.
* There is, by and large, a one-to-one mapping in each each IA332_ opt operator represents an
* IA32 opcde, so this method might seem useless. However, there are some special cases, notably
* for operand size. In this case, an opt operator of the form ADD__B would mean use the ADD IA32
* opcode with a byte operand size.
*/
private static Set<String> getMatchingOperators(String lowLevelOpcode) {
Iterator<String> e = OperatorFormatTables.getOpcodes();
Set<String> matchingOperators = new HashSet<String>();
while (e.hasNext()) {
String o = (String) e.next();
if (o.equals(lowLevelOpcode) || o.startsWith(lowLevelOpcode + "__")) matchingOperators.add(o);
}
return matchingOperators;
}
/**
* returns a list of all IA32_ opt compiler operators that do not correspond to real IA32 opcodes
* handled by the assembler. These are all supposed to have been removed by the time the assembler
* is called, so the assembler actually seeing such an opcode is an internal compiler error. This
* set is used during generating of error checking code.
*
* @param emittedOpcodes the set of IA32 opcodes the assembler understands.
* @return the set of IA32 opt operators that the assembler does not understand.
*/
private static Set<String> getErrorOpcodes(Set<String> emittedOpcodes) {
Iterator<String> e = OperatorFormatTables.getOpcodes();
Set<String> errorOpcodes = new HashSet<String>();
while (e.hasNext()) {
String opcode = (String) e.next();
if (!emittedOpcodes.contains(opcode)) errorOpcodes.add(opcode);
}
return errorOpcodes;
}
