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(AbstractAssemblyResolutionFactory<?,?> factory, 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(AbstractAssemblyResolutionFactory<?,?> factory, PatternExpression lexp, MaskedLong rval, MaskedLong goal, Map<String,Long> vals, AssemblyResolvedPatterns cur, Set<SolverHint> hints, String description)
protected AssemblyResolution	solveRightSide(AbstractAssemblyResolutionFactory<?,?> factory, PatternExpression rexp, MaskedLong lval, MaskedLong goal, Map<String,Long> vals, AssemblyResolvedPatterns cur, Set<SolverHint> hints, String description)
protected AssemblyResolution	solveTwoSided(AbstractAssemblyResolutionFactory<?,?> factory, 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(AbstractAssemblyResolutionFactory<?,?> factory,
 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>

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(AbstractAssemblyResolutionFactory<?,?> factory,
 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(AbstractAssemblyResolutionFactory<?,?> factory,
 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(AbstractAssemblyResolutionFactory<?,?> factory,
 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