ByteCode.java

  1. /*
  2.  *  Licensed to the Apache Software Foundation (ASF) under one or more
  3.  *  contributor license agreements.  See the NOTICE file distributed with
  4.  *  this work for additional information regarding copyright ownership.
  5.  *  The ASF licenses this file to You under the Apache License, Version 2.0
  6.  *  (the "License"); you may not use this file except in compliance with
  7.  *  the License.  You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  *  Unless required by applicable law or agreed to in writing, software
  12.  *  distributed under the License is distributed on an "AS IS" BASIS,
  13.  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  *  See the License for the specific language governing permissions and
  15.  *  limitations under the License.
  16.  */
  17. package org.apache.commons.compress.harmony.unpack200.bytecode;

  19. import java.io.DataOutputStream;
  20. import java.io.IOException;

  22. import org.apache.commons.compress.harmony.unpack200.Segment;
  23. import org.apache.commons.compress.harmony.unpack200.bytecode.forms.ByteCodeForm;

  25. /**
  26.  * A bytecode class file entry.
  27.  */
  28. public class ByteCode extends ClassFileEntry {

  30.     private static ByteCode[] noArgByteCodes = new ByteCode[255];

  32.     public static ByteCode getByteCode(final int opcode) {
  33.         final int byteOpcode = 0xFF & opcode;
  34.         if (ByteCodeForm.get(byteOpcode).hasNoOperand()) {
  35.             if (null == noArgByteCodes[byteOpcode]) {
  36.                 noArgByteCodes[byteOpcode] = new ByteCode(byteOpcode);
  37.             }
  38.             return noArgByteCodes[byteOpcode];
  39.         }
  40.         return new ByteCode(byteOpcode);
  41.     }

  43.     private final ByteCodeForm byteCodeForm;

  45.     private ClassFileEntry[] nested;
  46.     private int[][] nestedPositions;
  47.     private int[] rewrite;

  49.     private int byteCodeOffset = -1;
  50.     private int[] byteCodeTargets;

  52.     protected ByteCode(final int opcode) {
  53.         this(opcode, NONE);
  54.     }

  56.     protected ByteCode(final int opcode, final ClassFileEntry[] nested) {
  57.         this.byteCodeForm = ByteCodeForm.get(opcode);
  58.         this.rewrite = byteCodeForm.getRewriteCopy();
  59.         this.nested = nested;
  60.     }

  62.     /**
  63.      * Some ByteCodes (in particular, those with labels need to be fixed up after all the bytecodes in the CodeAttribute have been added. (This can't be done
  64.      * beforehand because the CodeAttribute needs to be complete before targets can be assigned.)
  65.      *
  66.      * @param codeAttribute the code attribute
  67.      */
  68.     public void applyByteCodeTargetFixup(final CodeAttribute codeAttribute) {
  69.         getByteCodeForm().fixUpByteCodeTargets(this, codeAttribute);
  70.     }

  72.     @Override
  73.     protected void doWrite(final DataOutputStream dos) throws IOException {
  74.         for (final int element : rewrite) {
  75.             dos.writeByte(element);
  76.         }
  77.     }

  79.     @Override
  80.     public boolean equals(final Object obj) {
  81.         return this == obj;
  82.     }

  84.     public void extractOperands(final OperandManager operandManager, final Segment segment, final int codeLength) {
  85.         // Given an OperandTable, figure out which operands
  86.         // the receiver needs and stuff them in operands.
  87.         // Later on the operands can be rewritten (But that's
  88.         // later, not now).
  89.         final ByteCodeForm currentByteCodeForm = getByteCodeForm();
  90.         currentByteCodeForm.setByteCodeOperands(this, operandManager, codeLength);
  91.     }

  93.     protected ByteCodeForm getByteCodeForm() {
  94.         return byteCodeForm;
  95.     }

  97.     public int getByteCodeIndex() {
  98.         return byteCodeOffset;
  99.     }

  101.     public int[] getByteCodeTargets() {
  102.         return byteCodeTargets;
  103.     }

  105.     public int getLength() {
  106.         return rewrite.length;
  107.     }

  109.     public String getName() {
  110.         return getByteCodeForm().getName();
  111.     }

  113.     @Override
  114.     public ClassFileEntry[] getNestedClassFileEntries() {
  115.         return nested;
  116.     }

  118.     public int[] getNestedPosition(final int index) {
  119.         return getNestedPositions()[index];
  120.     }

  122.     public int[][] getNestedPositions() {
  123.         return nestedPositions;
  124.     }

  126.     public int getOpcode() {
  127.         return getByteCodeForm().getOpcode();
  128.     }

  130.     /**
  131.      * Some bytecodes (the ones with variable lengths) can't have a static rewrite array - they need the ability to update the array. This method permits their
  132.      * associated bytecode formst to query their rewrite array.
  133.      *
  134.      * Note that this should not be called from bytecodes which have a static rewrite; use the table in ByteCodeForm instead to specify those rewrites.
  135.      *
  136.      * @return Some bytecodes.
  137.      */
  138.     public int[] getRewrite() {
  139.         return rewrite;
  140.     }

  142.     @Override
  143.     public int hashCode() {
  144.         return objectHashCode();
  145.     }

  147.     /**
  148.      * This method will answer true if the receiver is a multi-bytecode instruction (such as aload0_putfield_super); otherwise, it will answer false.
  149.      *
  150.      * @return boolean true if multibytecode, false otherwise
  151.      */
  152.     public boolean hasMultipleByteCodes() {
  153.         return getByteCodeForm().hasMultipleByteCodes();
  154.     }

  156.     public boolean nestedMustStartClassPool() {
  157.         return byteCodeForm.nestedMustStartClassPool();
  158.     }

  160.     /*
  161.      * (non-Javadoc)
  162.      *
  163.      * @see org.apache.commons.compress.harmony.unpack200.bytecode.ClassFileEntry#resolve(org.apache.commons.compress.harmony
  164.      * .unpack200.bytecode.ClassConstantPool)
  165.      */
  166.     @Override
  167.     protected void resolve(final ClassConstantPool pool) {
  168.         super.resolve(pool);
  169.         if (nested.length > 0) {
  170.             // Update the bytecode rewrite array so that it points
  171.             // to the elements of the nested array.
  172.             for (int index = 0; index < nested.length; index++) {
  173.                 final int argLength = getNestedPosition(index)[1];
  174.                 switch (argLength) {

  176.                 case 1:
  177.                     setOperandByte(pool.indexOf(nested[index]), getNestedPosition(index)[0]);
  178.                     break;

  180.                 case 2:
  181.                     setOperand2Bytes(pool.indexOf(nested[index]), getNestedPosition(index)[0]);
  182.                     break;

  184.                 default:
  185.                     throw new Error("Unhandled resolve " + this);
  186.                 }
  187.             }
  188.         }
  189.     }

  191.     /**
  192.      * ByteCodes may need to know their position in the code array (in particular, label byte codes need to know where they are in order to calculate their
  193.      * targets). This method lets the CodeAttribute specify where the byte code is.
  194.      *
  195.      * Since there are no aload0+label instructions, this method doesn't worry about multioperation bytecodes.
  196.      *
  197.      * @param byteCodeOffset int position in code array.
  198.      */
  199.     public void setByteCodeIndex(final int byteCodeOffset) {
  200.         this.byteCodeOffset = byteCodeOffset;
  201.     }

  203.     /**
  204.      * Some ByteCodes (in particular, those with labels) have to keep track of byteCodeTargets. These are initially offsets in the CodeAttribute array relative
  205.      * to the byteCodeOffset, but later get fixed up to point to the absolute position in the CodeAttribute array. This method sets the targets.
  206.      *
  207.      * @param byteCodeTargets int index in array
  208.      */
  209.     public void setByteCodeTargets(final int[] byteCodeTargets) {
  210.         this.byteCodeTargets = byteCodeTargets;
  211.     }

  213.     public void setNested(final ClassFileEntry[] nested) {
  214.         this.nested = nested;
  215.     }

  217.     /**
  218.      * nestedPositions is an array of arrays of ints. Each subarray specifies a position of a nested element (from the nested[] array) and the length of that
  219.      * element.
  220.      *
  221.      * For instance, one might have a nested of: {CPClass java/lang/Foo, CPFloat 3.14} The nestedPositions would then be: {{0,2},{2,2}} In other words, when the
  222.      * bytecode is resolved, the CPClass will be resolved to an int and inserted at position 0 and 1 of the rewrite arguments (the first occurrences of -1). The
  223.      * CPFloat will be resolved to an int position and inserted at positions 2 and 3 of the rewrite arguments.
  224.      *
  225.      * @param nestedPositions Each subarray specifies a position of a nested element (from the nested[] array) and the length of that element.
  226.      */
  227.     public void setNestedPositions(final int[][] nestedPositions) {
  228.         this.nestedPositions = nestedPositions;
  229.     }

  231.     /**
  232.      * Given an int operand, set the rewrite bytes for that position and the one immediately following it to a high-byte, low-byte encoding of the operand.
  233.      *
  234.      * @param operand  int to set the rewrite bytes to
  235.      * @param position int position in the operands of the rewrite bytes. For a rewrite array of {100, -1, -1, -1} position 0 is the first -1, position 1 is the
  236.      *                 second -1, etc.
  237.      */
  238.     public void setOperand2Bytes(final int operand, final int position) {
  239.         final int firstOperandIndex = getByteCodeForm().firstOperandIndex();
  240.         final int byteCodeFormLength = getByteCodeForm().getRewrite().length;
  241.         if (firstOperandIndex < 1) {
  242.             // No operand rewriting permitted for this bytecode
  243.             throw new Error("Trying to rewrite " + this + " that has no rewrite");
  244.         }

  246.         if (firstOperandIndex + position + 1 > byteCodeFormLength) {
  247.             throw new Error("Trying to rewrite " + this + " with an int at position " + position + " but this won't fit in the rewrite array");
  248.         }

  250.         rewrite[firstOperandIndex + position] = (operand & 0xFF00) >> 8;
  251.         rewrite[firstOperandIndex + position + 1] = operand & 0xFF;
  252.     }

  254.     /**
  255.      * Given an int operand, treat it as a byte and set the rewrite byte for that position to that value. Mask of anything beyond 0xFF.
  256.      *
  257.      * @param operand  int to set the rewrite byte to (unsigned)
  258.      * @param position int position in the operands of the rewrite bytes. For a rewrite array of {100, -1, -1, -1} position 0 is the first -1, position 1 is the
  259.      *                 second -1, etc.
  260.      */
  261.     public void setOperandByte(final int operand, final int position) {
  262.         final int firstOperandIndex = getByteCodeForm().firstOperandIndex();
  263.         final int byteCodeFormLength = getByteCodeForm().operandLength();
  264.         if (firstOperandIndex < 1) {
  265.             // No operand rewriting permitted for this bytecode
  266.             throw new Error("Trying to rewrite " + this + " that has no rewrite");
  267.         }

  269.         if (firstOperandIndex + position > byteCodeFormLength) {
  270.             throw new Error("Trying to rewrite " + this + " with an byte at position " + position + " but this won't fit in the rewrite array");
  271.         }

  273.         rewrite[firstOperandIndex + position] = operand & 0xFF;
  274.     }

  276.     /**
  277.      * Given an array of ints which correspond to bytes in the operand of the bytecode, set the rewrite bytes of the operand to be the appropriate values. All
  278.      * values in operands[] will be masked with 0xFF so they fit into a byte.
  279.      *
  280.      * @param operands int[] rewrite operand bytes
  281.      */
  282.     public void setOperandBytes(final int[] operands) {
  283.         final int firstOperandIndex = getByteCodeForm().firstOperandIndex();
  284.         final int byteCodeFormLength = getByteCodeForm().operandLength();
  285.         if (firstOperandIndex < 1) {
  286.             // No operand rewriting permitted for this bytecode
  287.             throw new Error("Trying to rewrite " + this + " that has no rewrite");
  288.         }

  290.         if (byteCodeFormLength != operands.length) {
  291.             throw new Error("Trying to rewrite " + this + " with " + operands.length + " but bytecode has length " + byteCodeForm.operandLength());
  292.         }

  294.         for (int index = 0; index < byteCodeFormLength; index++) {
  295.             rewrite[index + firstOperandIndex] = operands[index] & 0xFF;
  296.         }
  297.     }

  299.     /**
  300.      * This is just like setOperandInt, but takes special care when the operand is less than 0 to make sure it's written correctly.
  301.      *
  302.      * @param operand  int to set the rewrite bytes to
  303.      * @param position int position of the operands in the rewrite bytes
  304.      */
  305.     public void setOperandSigned2Bytes(final int operand, final int position) {
  306.         if (operand >= 0) {
  307.             setOperand2Bytes(operand, position);
  308.         } else {
  309.             final int twosComplementOperand = 0x10000 + operand;
  310.             setOperand2Bytes(twosComplementOperand, position);
  311.         }
  312.     }

  314.     /**
  315.      * Some bytecodes (the ones with variable lengths) can't have a static rewrite array - they need the ability to update the array. This method permits that.
  316.      *
  317.      * Note that this should not be called from bytecodes which have a static rewrite; use the table in ByteCodeForm instead to specify those rewrites.
  318.      *
  319.      * @param rewrite Some bytecodes.
  320.      */
  321.     public void setRewrite(final int[] rewrite) {
  322.         this.rewrite = rewrite;
  323.     }

  325.     @Override
  326.     public String toString() {
  327.         return getByteCodeForm().getName();
  328.     }
  329. }
Created with JaCoCo 0.8.12.202403310830