Package ghidra.pcode.emu.jit.alloc

Record Class AlignedMpIntHandler

java.lang.Object
java.lang.Record
ghidra.pcode.emu.jit.alloc.AlignedMpIntHandler
Record Components:
legs - the list of legs in little-endian order
type - the type of the full multi-precision integer variable
vn - the complete varnode accessible to this handler
opnd - the (writable) list of local operands (in LE order)
roOpnd - the read-only version of opnd.
All Implemented Interfaces:
VarHandler
public record AlignedMpIntHandler(List<JvmLocal<Types.TInt,JitType.IntJitType>> legs, JitType.MpIntJitType type, Varnode vn, MpIntLocalOpnd opnd, MpIntLocalOpnd roOpnd) extends Record implements VarHandler
The handler used for a varnode requiring allocation of multiple integers, where those integers correspond exactly to the variable's legs.

In this case, we can usually give the operators direct access to the underlying mp-int operand. We do need to be careful that we don't unintentionally permit the operator to use the variable's storage for intermediate values. Thus, we have some provision for saying each leg is read-only, which will cause attempts to store into them to instead generate a writable temporary local. Such intermediate results will get written only by a call to genStoreFromOpnd(Emitter, JitCodeGenerator, Opnd, Ext, Scope).

  • Constructor Details

  • Method Details

    • genLoadToStack

      public <TT extends Types.BPrim<?>, TJT extends JitType.SimpleJitType<TT, TJT>, N extends Emitter.Next> Emitter<Emitter.Ent<N,TT>> genLoadToStack(Emitter<N> em, JitCodeGenerator<?> gen, TJT to, Opnd.Ext ext)
      Description copied from interface: VarHandler
      Emit bytecode to load the varnode's value onto the JVM stack.
      Specified by:
      genLoadToStack in interface VarHandler
      Type Parameters:
      TT - the JVM type of the value to load onto the stack
      TJT - the p-code type of the value to load onto the stack
      N - the incoming stack
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      to - the p-code type of the value expected on the JVM stack by the proceeding bytecode
      ext - the kind of extension to apply when adjusting from JVM size to varnode size
      Returns:
      the emitter typed with the resulting stack

    • genLoadToOpnd

      public <N extends Emitter.Next> Opnd.OpndEm<JitType.MpIntJitType,N> genLoadToOpnd(Emitter<N> em, JitCodeGenerator<?> gen, JitType.MpIntJitType to, Opnd.Ext ext, Scope scope)
      Description copied from interface: VarHandler
      Emit bytecode to load the varnode's value into several locals.
      Specified by:
      genLoadToOpnd in interface VarHandler
      Type Parameters:
      N - the incoming stack
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      to - the p-code type of the value expected on the JVM stack by the proceeding bytecode
      ext - the kind of extension to apply
      scope - a scope for generating temporary local storage
      Returns:
      the operand containing the locals, and the emitter typed with the incoming stack

    • genLoadLegToStack

      public <N extends Emitter.Next> Emitter<Emitter.Ent<N,Types.TInt>> genLoadLegToStack(Emitter<N> em, JitCodeGenerator<?> gen, JitType.MpIntJitType type, int leg, Opnd.Ext ext)
      Description copied from interface: VarHandler
      Emit bytecode to load one leg of a multi-precision value from the varnode onto the JVM stack.
      Specified by:
      genLoadLegToStack in interface VarHandler
      Type Parameters:
      N - the incoming stack
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      type - the p-code type of the complete multi-precision value
      leg - the index of the leg to load, 0 being least significant
      ext - the kind of extension to apply
      Returns:
      the emitter typed with the resulting stack, i.e., having the int leg pushed onto it

    • genLoadToArray

      public <N extends Emitter.Next> Emitter<Emitter.Ent<N,Types.TRef<int[]>>> genLoadToArray(Emitter<N> em, JitCodeGenerator<?> gen, JitType.MpIntJitType to, Opnd.Ext ext, Scope scope, int slack)
      Description copied from interface: VarHandler
      Emit bytecode to load the varnode's value into an integer array in little-endian order, pushing its ref onto the JVM stack.
      Specified by:
      genLoadToArray in interface VarHandler
      Type Parameters:
      N - the incoming stack
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      to - the p-code type of the complete multi-precision value
      ext - the kind of extension to apply
      scope - a scope for generating temporary local storage
      slack - the number of additional, more significant, elements to allocate in the array
      Returns:
      the emitter typed with the resulting stack, i.e., having the ref pushed onto it

    • genLoadToBool

      public <N extends Emitter.Next> Emitter<Emitter.Ent<N,Types.TInt>> genLoadToBool(Emitter<N> em, JitCodeGenerator<?> gen)
      Description copied from interface: VarHandler
      Emit bytecode to load the varnode's value, interpreted as a boolean, as an integer onto the JVM stack.
      Specified by:
      genLoadToBool in interface VarHandler
      Type Parameters:
      N - the incoming stack
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      Returns:
      the emitter typed with the resulting stack, i.e., having the int boolean pushed onto it

    • doGenStoreInt

      protected <N1 extends Emitter.Next, N0 extends Emitter.Ent<N1, Types.TInt>> Emitter<N1> doGenStoreInt(Emitter<N0> em, JitCodeGenerator<?> gen, JitType.IntJitType type, JvmLocal<Types.TInt,JitType.IntJitType> local, Opnd.Ext ext, Scope scope)
      Emit bytecode to store a JVM int from the stack into the given local
      Type Parameters:
      N1 - the tail of the incoming stack
      N0 - the incoming stack, having the int on top
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      type - the p-code type of the int on the stack
      local - the local to receive the value
      ext - the kind of extension to apply
      scope - a scope for generating local storage
      Returns:
      the emitter typed with the resulting stack, i.e., having popped the int

    • doGenStoreIntAndSign

      protected <N1 extends Emitter.Next, N0 extends Emitter.Ent<N1, Types.TInt>> Emitter<Emitter.Ent<N1,Types.TInt>> doGenStoreIntAndSign(Emitter<N0> em, JitCodeGenerator<?> gen, JitType.IntJitType type, JvmLocal<Types.TInt,JitType.IntJitType> local, Scope scope)
      Emit bytecode to compute the sign of the int on the stack, and store that int into a given local.

      The int is copied and stored into the given local. Then, the sign of the int is computed and remains on the stack. Signed extension is assumed.

      Type Parameters:
      N1 - the tail of the incoming stack
      N0 - the incoming stack, having the int on top
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      type - the p-code type of the int on the stack. Note that this type determines the position of the sign bit.
      local - the local to receive the value
      scope - a scope for generating local storage
      Returns:
      the emitter typed with the resulting stack, i.e., having popped the int and pushed the sign

    • doGenStoreLong

      protected <N1 extends Emitter.Next, N0 extends Emitter.Ent<N1, Types.TLong>> Emitter<N1> doGenStoreLong(Emitter<N0> em, JitCodeGenerator<?> gen, JitType.LongJitType type, JvmLocal<Types.TInt,JitType.IntJitType> lower, JvmLocal<Types.TInt,JitType.IntJitType> upper, Opnd.Ext ext, Scope scope)
      Emit bytecode to store a JVM long from the stack into two given locals
      Type Parameters:
      N1 - the tail of the incoming stack
      N0 - the incoming stack, having the long on top
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      type - the p-code type of the int on the stack
      lower - the local to receive the lower 32 bits of the value
      upper - the local to receive the upper 32 bits of the value
      ext - the kind of extension to apply
      scope - a scope for generating local storage
      Returns:
      the emitter typed with the resulting stack, i.e., having popped the long

    • doGenStoreLongAndSign

      protected <N1 extends Emitter.Next, N0 extends Emitter.Ent<N1, Types.TLong>> Emitter<Emitter.Ent<N1,Types.TInt>> doGenStoreLongAndSign(Emitter<N0> em, JitCodeGenerator<?> gen, JitType.LongJitType type, JvmLocal<Types.TInt,JitType.IntJitType> lower, JvmLocal<Types.TInt,JitType.IntJitType> upper, Scope scope)
      Emit bytecode to compute the sign of the long on the stack, and store that long into two given locals.

      The long is copied and stored into the given local. Then, the sign of the long is computed and remains on the stack as an int. Signed extension is assumed.

      Type Parameters:
      N1 - the tail of the incoming stack
      N0 - the incoming stack, having the long on top
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      type - the p-code type of the long on the stack. Note that this type determines the position of the sign bit.
      lower - the local to receive the lower 32 bits of the value
      upper - the local to receive the upper 32 bits of the value
      scope - a scope for generating local storage
      Returns:
      the emitter typed with the resulting stack, i.e., having popped the long and pushed the sign

    • doGenZeroFill

      protected <N extends Emitter.Next> Emitter<N> doGenZeroFill(Emitter<N> em, JitCodeGenerator<?> gen, List<JvmLocal<Types.TInt,JitType.IntJitType>> locals, Scope scope)
      Emit bytecode to zero fill the given locals
      Type Parameters:
      N - the incoming stack
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      locals - the locals to zero fill
      scope - a scope for generating local storage
      Returns:
      the emitter typed with the incoming stack

    • doGenSignFill

      protected <N1 extends Emitter.Next, N0 extends Emitter.Ent<N1, Types.TInt>> Emitter<N1> doGenSignFill(Emitter<N0> em, JitCodeGenerator<?> gen, List<JvmLocal<Types.TInt,JitType.IntJitType>> locals, Scope scope)
      Emit bytecode to sign fill the given locals
      Type Parameters:
      N1 - the tail of the incoming stack
      N0 - the incoming stack having the sign int on top
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      locals - the locals to sign fill
      scope - a scope for generating local storage
      Returns:
      the emitter typed with the resulting stack, i.e., having popped the sign

    • genStoreFromStack

      public <FT extends Types.BPrim<?>, FJT extends JitType.SimpleJitType<FT, FJT>, N1 extends Emitter.Next, N0 extends Emitter.Ent<N1, FT>> Emitter<N1> genStoreFromStack(Emitter<N0> em, JitCodeGenerator<?> gen, FJT from, Opnd.Ext ext, Scope scope)
      Description copied from interface: VarHandler
      Emit bytecode to store a value into a variable from the JVM stack.
      Specified by:
      genStoreFromStack in interface VarHandler
      Type Parameters:
      FT - the JVM type of the value on the stack
      FJT - the p-code type of the value on the stack
      N1 - the tail of the incoming stack
      N0 - the incoming stack having the value to store on top
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      from - the p-code type of the value on the stack
      ext - the kind of extension to apply
      scope - a scope for generating temporary local storage
      Returns:
      the emitter typed with the resulting stack, i.e., having popped the value

    • genExt

      protected <N extends Emitter.Next> Emitter<N> genExt(Emitter<N> em, JitCodeGenerator<?> gen, int defLegs, int legsOut, Opnd.Ext ext, Scope scope)
      Emit bytecode to extend the value stored in our legs.
      Type Parameters:
      N - the tail of the incoming stack
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      defLegs - the number of legs having the input value
      legsOut - the number of legs to receive the output value. If this is less than or equal to defLegs, there is no extension to apply, so no code is emitted.
      ext - the kind of extension to apply
      scope - a scope for generating temporary local storage
      Returns:
      the emitter typed with the incoming stack

    • genStoreFromOpnd

      public <N extends Emitter.Next> Emitter<N> genStoreFromOpnd(Emitter<N> em, JitCodeGenerator<?> gen, Opnd<JitType.MpIntJitType> from, Opnd.Ext ext, Scope scope)
      Description copied from interface: VarHandler
      Emit bytecode to store a varnode's value from several locals.
      Specified by:
      genStoreFromOpnd in interface VarHandler
      Type Parameters:
      N - the incoming stack
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      from - the operand whose locals contain the value to be stored
      ext - the kind of extension to apply
      scope - a scope for generating temporary local storage
      Returns:
      the emitter typed with the incoming stack

    • genStoreFromArray

      public <N1 extends Emitter.Next, N0 extends Emitter.Ent<N1, Types.TRef<int[]>>> Emitter<N1> genStoreFromArray(Emitter<N0> em, JitCodeGenerator<?> gen, JitType.MpIntJitType from, Opnd.Ext ext, Scope scope)
      Description copied from interface: VarHandler
      Emit bytecode to store a varnode's value from an array of integer legs, in little endian order
      Specified by:
      genStoreFromArray in interface VarHandler
      Type Parameters:
      N1 - the tail of the incoming stack
      N0 - the incoming stack having the array ref on top
      Parameters:
      em - the emitter typed with the incoming stack
      gen - the code generator
      from - the p-code type of the value on the stack
      ext - the kind of extension to apply
      scope - a scope for generating temporary local storage
      Returns:
      the emitter typed with the resulting stack, i.e., having popped the array

    • subpiece

      public VarHandler subpiece(Endian endian, int byteOffset, int maxByteSize)
      Description copied from interface: VarHandler
      Create a handler for a PcodeOp.SUBPIECE of a value.

      To implement subpiece, we could load the entire varnode and then extract the designated portion. Or, we could load only the designated portion, averting any code and execution cost of loading the un-designated portions. We accomplish this by re-writing the subpiece op and a load of the sub-varnode.

      Specified by:
      subpiece in interface VarHandler
      Parameters:
      endian - the endianness of the emulation target
      byteOffset - the number of least-significant bytes to remove
      maxByteSize - the maximum size of the resulting variable. In general, a subpiece should never exceed the size of the parent varnode, but if it does, this will truncate that excess.
      Returns:
      the resulting subpiece handler

    • toString

      public final String toString()
      Returns a string representation of this record class. The representation contains the name of the class, followed by the name and value of each of the record components.
      Specified by:
      toString in class Record
      Returns:
      a string representation of this object

    • hashCode

      public final int hashCode()
      Returns a hash code value for this object. The value is derived from the hash code of each of the record components.
      Specified by:
      hashCode in class Record
      Returns:
      a hash code value for this object

    • equals

      public final boolean equals(Object o)
      Indicates whether some other object is "equal to" this one. The objects are equal if the other object is of the same class and if all the record components are equal. All components in this record class are compared with Objects::equals(Object,Object).
      Specified by:
      equals in class Record
      Parameters:
      o - the object with which to compare
      Returns:
      true if this object is the same as the o argument; false otherwise.

    • legs

      public List<JvmLocal<Types.TInt,JitType.IntJitType>> legs()
      Returns the value of the legs record component.
      Returns:
      the value of the legs record component

    • type

      public JitType.MpIntJitType type()
      Returns the value of the type record component.
      Specified by:
      type in interface VarHandler
      Returns:
      the value of the type record component

    • vn

      public Varnode vn()
      Returns the value of the vn record component.
      Specified by:
      vn in interface VarHandler
      Returns:
      the value of the vn record component

    • opnd

      public MpIntLocalOpnd opnd()
      Returns the value of the opnd record component.
      Returns:
      the value of the opnd record component

    • roOpnd

      public MpIntLocalOpnd roOpnd()
      Returns the value of the roOpnd record component.
      Returns:
      the value of the roOpnd record component