Package ghidra.app.plugin.assembler.sleigh.expr

# Class AbstractBinaryExpressionSolver<T extends BinaryExpression>

java.lang.Object
ghidra.app.plugin.assembler.sleigh.expr.AbstractExpressionSolver<T>
ghidra.app.plugin.assembler.sleigh.expr.AbstractBinaryExpressionSolver<T>

Type Parameters:
  `T` - the type of expression solved (the operator)

Direct Known Subclasses:
  `AndExpressionSolver`, `DivExpressionSolver`, `LeftShiftExpressionSolver`, `MultExpressionSolver`, `OrExpressionSolver`, `PlusExpressionSolver`, `RightShiftExpressionSolver`, `SubExpressionSolver`, `XorExpressionSolver`

public abstract class AbstractBinaryExpressionSolver<T extends BinaryExpression> extends AbstractExpressionSolver<T>
A solver that handles expressions of the form `A [OP] B`

- ## Field Summary

  ### Fields inherited from class ghidra.app.plugin.assembler.sleigh.expr.AbstractExpressionSolver

  `dbg, solver`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `AbstractBinaryExpressionSolver(Class<T> tcls)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `abstract MaskedLong`
  `compute(MaskedLong lval, MaskedLong rval)`
  Compute the result of applying the operator to the two given values
  `abstract MaskedLong`
  `computeLeft(MaskedLong rval, MaskedLong goal)`
  Compute the left-hand-side value given that the result and the right are known
  `MaskedLong`
  `computeRight(MaskedLong lval, MaskedLong goal)`
  Compute the right-hand-side value given that the result and the left are known
  `int`
  `getInstructionLength(T exp)`
  Determines the length of the subconstructor that would be returned had the expression not depended on an undefined symbol.
  `MaskedLong`
  `getValue(T exp, Map<String,Long> vals, AssemblyResolvedPatterns cur)`
  Attempt to get a constant value for the expression
  `AssemblyResolution`
  `solve(T exp, MaskedLong goal, Map<String,Long> vals, AssemblyResolvedPatterns cur, Set<SolverHint> hints, String description)`
  Attempt to solve an expression for a given value
  `protected AssemblyResolution`
  `solveLeftSide(PatternExpression lexp, MaskedLong rval, MaskedLong goal, Map<String,Long> vals, AssemblyResolvedPatterns cur, Set<SolverHint> hints, String description)`
  `protected AssemblyResolution`
  `solveRightSide(PatternExpression rexp, MaskedLong lval, MaskedLong goal, Map<String,Long> vals, AssemblyResolvedPatterns cur, Set<SolverHint> hints, String description)`
  `protected AssemblyResolution`
  `solveTwoSided(T exp, MaskedLong goal, Map<String,Long> vals, AssemblyResolvedPatterns cur, Set<SolverHint> hints, String description)`
  `MaskedLong`
  `valueForResolution(T exp, Map<String,Long> vals, AssemblyResolvedPatterns rc)`
  Compute the value of the expression given the (possibly-intermediate) resolution

  ### Methods inherited from class ghidra.app.plugin.assembler.sleigh.expr.AbstractExpressionSolver

  `register`

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Constructor Details

  - ### AbstractBinaryExpressionSolver

    public AbstractBinaryExpressionSolver(Class<T> tcls)

- ## Method Details

  - ### solve

    public AssemblyResolution solve(T exp, MaskedLong goal, Map<String,Long> vals, AssemblyResolvedPatterns cur, Set<SolverHint> hints, String description) throws NeedsBackfillException
    Description copied from class: `AbstractExpressionSolver`
    Attempt to solve an expression for a given value
    Specified by:
      `solve` in class `AbstractExpressionSolver<T extends BinaryExpression>`
    Parameters:
      `exp` - the expression to solve
      `goal` - the desired value of the expression
      `vals` - values of defined symbols
      `hints` - describes techniques applied by calling solvers
      `description` - the description to give to resolved solutions
    Returns:
      the resolution
    Throws:
      `NeedsBackfillException` - if the expression refers to an undefined symbol

  - ### solveLeftSide

    protected AssemblyResolution solveLeftSide(PatternExpression lexp, MaskedLong rval, MaskedLong goal, Map<String,Long> vals, AssemblyResolvedPatterns cur, Set<SolverHint> hints, String description) throws NeedsBackfillException, SolverException
    Throws:
      `NeedsBackfillException`
      `SolverException`

  - ### solveRightSide

    protected AssemblyResolution solveRightSide(PatternExpression rexp, MaskedLong lval, MaskedLong goal, Map<String,Long> vals, AssemblyResolvedPatterns cur, Set<SolverHint> hints, String description) throws NeedsBackfillException, SolverException
    Throws:
      `NeedsBackfillException`
      `SolverException`

  - ### solveTwoSided

    protected AssemblyResolution solveTwoSided(T exp, MaskedLong goal, Map<String,Long> vals, AssemblyResolvedPatterns cur, Set<SolverHint> hints, String description) throws NeedsBackfillException, SolverException
    Throws:
      `NeedsBackfillException`
      `SolverException`

  - ### getValue

    public MaskedLong getValue(T exp, Map<String,Long> vals, AssemblyResolvedPatterns cur) throws NeedsBackfillException
    Description copied from class: `AbstractExpressionSolver`
    Attempt to get a constant value for the expression
    Specified by:
      `getValue` in class `AbstractExpressionSolver<T extends BinaryExpression>`
    Parameters:
      `exp` - the expression
      `vals` - values of defined symbols
    Returns:
      the constant value, or null if it depends on a variable
    Throws:
      `NeedsBackfillException` - if the expression refers to an undefined symbol

  - ### computeLeft

    public abstract MaskedLong computeLeft(MaskedLong rval, MaskedLong goal) throws SolverException
    Compute the left-hand-side value given that the result and the right are known
    Parameters:
      `rval` - the right-hand-side value
      `goal` - the result
    Returns:
      the left-hand-side value solution
    Throws:
      `SolverException` - if the expression cannot be solved

  - ### computeRight

    public MaskedLong computeRight(MaskedLong lval, MaskedLong goal) throws SolverException
    Compute the right-hand-side value given that the result and the left are known

    NOTE: Assumes commutativity by default

    Parameters:
      `lval` - the left-hand-side value
      `goal` - the result
    Returns:
      the right-hand-side value solution
    Throws:
      `SolverException` - if the expression cannot be solved

  - ### compute

    public abstract MaskedLong compute(MaskedLong lval, MaskedLong rval)
    Compute the result of applying the operator to the two given values
    Parameters:
      `lval` - the left-hand-side value
      `rval` - the right-hand-side value
    Returns:
      the result

  - ### getInstructionLength

    public int getInstructionLength(T exp)
    Description copied from class: `AbstractExpressionSolver`
    Determines the length of the subconstructor that would be returned had the expression not depended on an undefined symbol.

    This is used by the backfilling process to ensure values are written to the correct offset

    Specified by:
      `getInstructionLength` in class `AbstractExpressionSolver<T extends BinaryExpression>`
    Parameters:
      `exp` - the expression
    Returns:
      the length of filled in token field(s).

  - ### valueForResolution

    public MaskedLong valueForResolution(T exp, Map<String,Long> vals, AssemblyResolvedPatterns rc)
    Description copied from class: `AbstractExpressionSolver`
    Compute the value of the expression given the (possibly-intermediate) resolution
    Specified by:
      `valueForResolution` in class `AbstractExpressionSolver<T extends BinaryExpression>`
    Parameters:
      `exp` - the expression to evaluate
      `vals` - values of defined symbols
      `rc` - the resolution on which to evaluate it
    Returns:
      the result