truffle: graal/com.oracle.max.cri/src/com/sun/cri/bytecode/Bytecodes.java comparison

comparison graal/com.oracle.max.cri/src/com/sun/cri/bytecode/Bytecodes.java @ 4142:bc8527f3071c

Adjust code base to new level of warnings.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Sun, 18 Dec 2011 05:24:06 +0100
parents	e233f5660da4
children

comparison

equal deleted inserted replaced

-:04d21be7a24f
+:bc8527f3071c
 public static final int IFNONNULL            = 199; // 0xC7
 public static final int GOTO_W               = 200; // 0xC8
 public static final int JSR_W                = 201; // 0xC9
 public static final int BREAKPOINT           = 202; // 0xCA
-// Start extended bytecodes
-/**
-* Native function call.
-*
-* The 'function_address' value on the top of the stack is the result of
-* linking a native function.
-*
-* <pre>
-* Format: { u1 opcode;  // JNICALL
-*           u2 sig;     // Constant pool index of a CONSTANT_Utf8_info representing the signature of the call
-*         }
-*
-* Operand Stack:
-*     ..., [arg1, [arg2 ... ]] function_address => [return value, ]...,
-* </pre>
-*
-* @see #JNIOP_LINK
-* @see #JNIOP_J2N
-* @see #JNIOP_N2J
-*/
-public static final int JNICALL              = 203;
-// End extended bytecodes
 public static final int ILLEGAL = 255;
 public static final int END = 256;
 /**
 * The last opcode defined by the JVM specification. To iterate over all JVM bytecodes:
 /**
 * A array that maps from a bytecode value to a {@link String} for the corresponding instruction mnemonic.
 * This will include the root instruction for the three-byte extended instructions.
 */
-private static final String[] names = new String[256];
+private static final String[] nameArray = new String[256];
 /**
 * A array that maps from a bytecode value to the set of {@link Flags} for the corresponding instruction.
 */
-private static final int[] flags = new int[256];
+private static final int[] flagsArray = new int[256];
 /**
 * A array that maps from a bytecode value to the length in bytes for the corresponding instruction.
 */
-private static final int[] length = new int[256];
+private static final int[] lengthArray = new int[256];
 // Checkstyle: stop
 static {
 def(NOP                 , "nop"             , "b"    );
 def(ACONST_NULL         , "aconst_null"     , "b"    );
 def(IFNULL              , "ifnull"          , "boo"  , FALL_THROUGH | BRANCH);
 def(IFNONNULL           , "ifnonnull"       , "boo"  , FALL_THROUGH | BRANCH);
 def(GOTO_W              , "goto_w"          , "boooo", STOP | BRANCH);
 def(JSR_W               , "jsr_w"           , "boooo", STOP | BRANCH);
 def(BREAKPOINT          , "breakpoint"      , "b"    , TRAP);
-def(JNICALL             , "jnicall"         , "bii"  , EXTENSION | TRAP);
 }
 // Checkstyle: resume
 /**
 * Determines if an opcode is commutative.
 * @param opcode the opcode to check
 * @return {@code true} iff commutative
 */
 public static boolean isCommutative(int opcode) {
-return (flags[opcode & 0xff] & COMMUTATIVE) != 0;
+return (flagsArray[opcode & 0xff] & COMMUTATIVE) != 0;
 }
 /**
 * Gets the length of an instruction denoted by a given opcode.
 *
 * @param opcode an instruction opcode
 * @return the length of the instruction denoted by {@code opcode}. If {@code opcode} is an illegal instruction or denotes a
 *         variable length instruction (e.g. {@link #TABLESWITCH}), then 0 is returned.
 */
 public static int lengthOf(int opcode) {
-return length[opcode & 0xff];
+return lengthArray[opcode & 0xff];
 }
 /**
 * Gets the length of an instruction at a given position in a given bytecode array.
 * This methods handles variable length and {@linkplain #WIDE widened} instructions.
 * @param bci the position in {@code code} of an instruction's opcode
 * @return the length of the instruction at position {@code bci} in {@code code}
 */
 public static int lengthOf(byte[] code, int bci) {
 int opcode = Bytes.beU1(code, bci);
-int length = Bytecodes.length[opcode & 0xff];
+int length = Bytecodes.lengthArray[opcode & 0xff];
 if (length == 0) {
 switch (opcode) {
 case TABLESWITCH: {
 return new BytecodeTableSwitch(code, bci).size();
 }
 *
 * @param opcode an opcode
 * @return the mnemonic for {@code opcode} or {@code "<illegal opcode: " + opcode + ">"} if {@code opcode} is not a legal opcode
 */
 public static String nameOf(int opcode) throws IllegalArgumentException {
-String name = names[opcode & 0xff];
+String name = nameArray[opcode & 0xff];
 if (name == null) {
 return "<illegal opcode: " + opcode + ">";
 }
 return name;
 }
 * Allocation-free version of {@linkplain #nameOf(int)}.
 * @param opcode an opcode.
 * @return the mnemonic for {@code opcode} or {@code "<illegal opcode>"} if {@code opcode} is not a legal opcode.
 */
 public static String baseNameOf(int opcode) {
-String name = names[opcode & 0xff];
+String name = nameArray[opcode & 0xff];
 if (name == null) {
 return "<illegal opcode>";
 }
 return name;
 }
 * @param name an opcode mnemonic
 * @return the opcode corresponding to {@code mnemonic}
 * @throws IllegalArgumentException if {@code name} does not denote a valid opcode
 */
 public static int valueOf(String name) {
-for (int opcode = 0; opcode < names.length; ++opcode) {
+for (int opcode = 0; opcode < nameArray.length; ++opcode) {
-if (name.equalsIgnoreCase(names[opcode])) {
+if (name.equalsIgnoreCase(nameArray[opcode])) {
 return opcode;
 }
 }
 throw new IllegalArgumentException("No opcode for " + name);
 }
 *
 * @param opcode an opcode to test
 * @return {@code true} iff {@code opcode} can cause an implicit exception, {@code false} otherwise
 */
 public static boolean canTrap(int opcode) {
-return (flags[opcode & 0xff] & TRAP) != 0;
+return (flagsArray[opcode & 0xff] & TRAP) != 0;
 }
 /**
 * Determines if a given opcode denotes an instruction that loads a local variable to the operand stack.
 *
 * @param opcode an opcode to test
 * @return {@code true} iff {@code opcode} loads a local variable to the operand stack, {@code false} otherwise
 */
 public static boolean isLoad(int opcode) {
-return (flags[opcode & 0xff] & LOAD) != 0;
+return (flagsArray[opcode & 0xff] & LOAD) != 0;
 }
 /**
 * Determines if a given opcode denotes an instruction that ends a basic block and does not let control flow fall
 * through to its lexical successor.
 *
 * @param opcode an opcode to test
 * @return {@code true} iff {@code opcode} properly ends a basic block
 */
 public static boolean isStop(int opcode) {
-return (flags[opcode & 0xff] & STOP) != 0;
+return (flagsArray[opcode & 0xff] & STOP) != 0;
 }
 /**
 * Determines if a given opcode denotes an instruction that stores a value to a local variable
 * after popping it from the operand stack.
 *
 * @param opcode an opcode to test
 * @return {@code true} iff {@code opcode} stores a value to a local variable, {@code false} otherwise
 */
 public static boolean isInvoke(int opcode) {
-return (flags[opcode & 0xff] & INVOKE) != 0;
+return (flagsArray[opcode & 0xff] & INVOKE) != 0;
 }
 /**
 * Determines if a given opcode denotes an instruction that stores a value to a local variable
 * after popping it from the operand stack.
 *
 * @param opcode an opcode to test
 * @return {@code true} iff {@code opcode} stores a value to a local variable, {@code false} otherwise
 */
 public static boolean isStore(int opcode) {
-return (flags[opcode & 0xff] & STORE) != 0;
+return (flagsArray[opcode & 0xff] & STORE) != 0;
 }
 /**
 * Determines if a given opcode is an instruction that delimits a basic block.
 *
 * @param opcode an opcode to test
 * @return {@code true} iff {@code opcode} delimits a basic block
 */
 public static boolean isBlockEnd(int opcode) {
-return (flags[opcode & 0xff] & (STOP | FALL_THROUGH)) != 0;
+return (flagsArray[opcode & 0xff] & (STOP | FALL_THROUGH)) != 0;
 }
 /**
 * Determines if a given opcode is an instruction that has a 2 or 4 byte operand that is an offset to another
 * instruction in the same method. This does not include the {@linkplain #TABLESWITCH switch} instructions.
 *
 * @param opcode an opcode to test
 * @return {@code true} iff {@code opcode} is a branch instruction with a single operand
 */
 public static boolean isBranch(int opcode) {
-return (flags[opcode & 0xff] & BRANCH) != 0;
+return (flagsArray[opcode & 0xff] & BRANCH) != 0;
 }
 /**
 * Determines if a given opcode denotes a conditional branch.
 * @param opcode
 * @return {@code true} iff {@code opcode} is a conditional branch
 */
 public static boolean isConditionalBranch(int opcode) {
-return (flags[opcode & 0xff] & FALL_THROUGH) != 0;
+return (flagsArray[opcode & 0xff] & FALL_THROUGH) != 0;
 }
 /**
 * Determines if a given opcode denotes a standard bytecode. A standard bytecode is
 * defined in the JVM specification.
 *
 * @param opcode an opcode to test
 * @return {@code true} iff {@code opcode} is a standard bytecode
 */
 public static boolean isStandard(int opcode) {
-return (flags[opcode & 0xff] & EXTENSION) == 0;
+return (flagsArray[opcode & 0xff] & EXTENSION) == 0;
 }
 /**
 * Determines if a given opcode denotes an extended bytecode.
 *
 * @param opcode an opcode to test
 * @return {@code true} if {@code opcode} is an extended bytecode
 */
 public static boolean isExtended(int opcode) {
-return (flags[opcode & 0xff] & EXTENSION) != 0;
+return (flagsArray[opcode & 0xff] & EXTENSION) != 0;
 }
 /**
 * Determines if a given opcode is a three-byte extended bytecode.
 *
 /**
 * Defines a bytecode by entering it into the arrays that record its name, length and flags.
 *
 * @param name instruction name (should be lower case)
 * @param format encodes the length of the instruction
-* @param flags the set of {@link Flags} associated with the instruction
+* @param flagsArray the set of {@link Flags} associated with the instruction
 */
 private static void def(int opcode, String name, String format) {
 def(opcode, name, format, 0);
 }
 * @param name instruction name (lower case)
 * @param format encodes the length of the instruction
 * @param flags the set of {@link Flags} associated with the instruction
 */
 private static void def(int opcode, String name, String format, int flags) {
-assert names[opcode] == null : "opcode " + opcode + " is already bound to name " + names[opcode];
+assert nameArray[opcode] == null : "opcode " + opcode + " is already bound to name " + nameArray[opcode];
-names[opcode] = name;
+nameArray[opcode] = name;
 int instructionLength = format.length();
-length[opcode] = instructionLength;
+lengthArray[opcode] = instructionLength;
-Bytecodes.flags[opcode] = flags;
+Bytecodes.flagsArray[opcode] = flags;
 assert !isConditionalBranch(opcode) || isBranch(opcode) : "a conditional branch must also be a branch";
 }
 /**
 Matcher matcher = opcodeDecl.matcher(line);
 if (matcher.matches()) {
 String name = matcher.group(2);
 String value = matcher.group(4);
 int opcode = Integer.parseInt(value);
-if (names[opcode] == null || !names[opcode].equalsIgnoreCase(name)) {
+if (nameArray[opcode] == null || !nameArray[opcode].equalsIgnoreCase(name)) {
-throw new RuntimeException("Missing definition of name and flags for " + opcode + ":" + name + " -- " + names[opcode]);
+throw new RuntimeException("Missing definition of name and flags for " + opcode + ":" + name + " -- " + nameArray[opcode]);
 }
 if (opcode != lastExtendedOpcode + 1) {
 System.err.println("Fixed declaration of opcode " + name + " to be " + (lastExtendedOpcode + 1) + " (was " + value + ")");
 opcode = lastExtendedOpcode + 1;
 line = line.substring(0, matcher.start(4)) + opcode + line.substring(matcher.end(4));

Mercurial > hg > truffle

comparison graal/com.oracle.max.cri/src/com/sun/cri/bytecode/Bytecodes.java @ 4142:bc8527f3071c