This is the basic set of transformation Rule objects. More...

#include "action.hh"

Classes
class	AddTreeState
	Structure for sorting out pointer expression trees. More...

class	RuleEarlyRemoval
	Get rid of unused PcodeOp objects where we can guarantee the output is unused. More...

class	RuleCollectTerms
	Collect terms in a sum: `V * c + V * d => V * (c + d)` More...

class	RuleSelectCse
	Look for common sub-expressions (built out of a restricted set of ops) More...

class	RulePiece2Zext
	Concatenation with 0 becomes an extension: `V = concat(#0,W) => V = zext(W)` More...

class	RulePiece2Sext
	Concatenation with sign bits becomes an extension: `concat( V s>> #0x1f , V) => sext(V)` More...

class	RuleBxor2NotEqual
	Eliminate BOOL_XOR: `V ^^ W => V != W` More...

class	RuleOrMask
	Simplify INT_OR with full mask: `V = W \| 0xffff => V = W` More...

class	RuleAndMask
	Collapse unnecessary INT_AND. More...

class	RuleOrConsume
	Simply OR with unconsumed input: `V = A \| B => V = B if nzm(A) & consume(V) == 0. More...

class	RuleOrCollapse
	Collapse unnecessary INT_OR. More...

class	RuleAndOrLump
	Collapse constants in logical expressions: `(V & c) & d => V & (c & d)` More...

class	RuleNegateIdentity
	Apply INT_NEGATE identities: `V & ~V => #0, V \| ~V -> #-1` More...

class	RuleShiftBitops
	Shifting away all non-zero bits of one-side of a logical/arithmetic op. More...

class	RuleRightShiftAnd
	Simplify INT_RIGHT and INT_SRIGHT ops where an INT_AND mask becomes unnecessary. More...

class	RuleIntLessEqual
	Convert LESSEQUAL to LESS: `V <= c => V < (c+1)` More...

class	RuleEquality
	Collapse INT_EQUAL and INT_NOTEQUAL: `f(V,W) == f(V,W) => true` More...

class	RuleTermOrder
	Order the inputs to commutative operations. More...

class	RulePullsubMulti
	Pull SUBPIECE back through MULTIEQUAL. More...

class	RulePullsubIndirect
	Pull-back SUBPIECE through INDIRECT. More...

class	RulePushMulti
	Simplify MULTIEQUAL operations where the branches hold the same value. More...

class	RuleNotDistribute
	Distribute BOOL_NEGATE: `!(V && W) => !V \|\| !W` More...

class	RuleHighOrderAnd
	Simplify INT_AND when applied to aligned INT_ADD: `(V + c) & 0xfff0 => V + (c & 0xfff0)` More...

class	RuleAndDistribute
	Distribute INT_AND through INT_OR if result is simpler. More...

class	RuleLessOne
	Transform INT_LESS of 0 or 1: `V < 1 => V == 0, V <= 0 => V == 0` More...

class	RuleRangeMeld
	Merge range conditions of the form: `V s< c, c s< V, V == c, V != c` More...

class	RuleFloatRange
	Merge range conditions of the form: `V f< c, c f< V, V f== c` etc. More...

class	RuleAndCommute
	Commute INT_AND with INT_LEFT and INT_RIGHT: `(V << W) & d => (V & (W >> c)) << c` More...

class	RuleAndPiece
	Convert PIECE to INT_ZEXT where appropriate: `V & concat(W,X) => zext(X)` More...

class	RuleAndCompare
	Simplify INT_ZEXT and SUBPIECE in masked comparison: `zext(V) & c == 0 => V & (c & mask) == 0` More...

class	RuleDoubleSub
	Simplify chained SUBPIECE: `sub( sub(V,c), d) => sub(V, c+d)` More...

class	RuleDoubleShift
	Simplify chained shifts INT_LEFT and INT_RIGHT. More...

class	RuleDoubleArithShift
	Simplify two sequential INT_SRIGHT: `(x s>> #c) s>> #d => x s>> saturate(#c + #d)` More...

class	RuleConcatShift
	Simplify INT_RIGHT canceling PIECE: `concat(V,W) >> c => zext(V)` More...

class	RuleLeftRight
	Transform canceling INT_RIGHT or INT_SRIGHT of INT_LEFT. More...

class	RuleShiftCompare
	Transform shifts in comparisons: `V >> c == d => V == (d << c)` More...

class	RuleLessEqual
	Simplify 'less than or equal': `V < W \|\| V == W => V <= W` More...

class	RuleLessNotEqual
	Simplify INT_LESSEQUAL && INT_NOTEQUAL: `V <= W && V != W => V < W` More...

class	RuleTrivialArith
	Simplify trivial arithmetic expressions. More...

class	RuleTrivialBool
	Simplify boolean expressions when one side is constant. More...

class	RuleZextEliminate
	Eliminate INT_ZEXT in comparisons: `zext(V) == c => V == c` More...

class	RuleSlessToLess
	Convert INT_SLESS to INT_LESS when comparing positive values. More...

class	RuleZextSless
	Transform INT_ZEXT and INT_SLESS: `zext(V) s< c => V < c` More...

class	RuleBitUndistribute
	Undo distributed operations through INT_AND, INT_OR, and INT_XOR. More...

class	RuleBooleanNegate
	Simplify comparisons with boolean values: `V == false => !V, V == true => V` More...

class	RuleBoolZext
	Simplify boolean expressions of the form zext(V) * -1. More...

class	RuleLogic2Bool
	Convert logical to boolean operations: `V & W => V && W, V \| W => V \|\| W` More...

class	RuleIndirectCollapse
	Remove a CPUI_INDIRECT if its blocking PcodeOp is dead. More...

class	RuleMultiCollapse
	Collapse MULTIEQUAL whose inputs all trace to the same value. More...

class	RuleSborrow
	Simplify signed comparisons using INT_SBORROW. More...

class	RuleTrivialShift
	Simplify trivial shifts: `V << 0 => V, V << #64 => 0` More...

class	RuleSignShift
	Normalize sign-bit extraction: `V >> 0x1f => (V s>> 0x1f) * -1` More...

class	RuleTestSign
	Convert sign-bit test to signed comparison: `(V s>> 0x1f) != 0 => V s< 0` More...

class	RuleIdentityEl
	Collapse operations using identity element: `V + 0 => V` More...

class	RuleShift2Mult
	Convert INT_LEFT to INT_MULT: `V << 2 => V * 4` More...

class	RuleShiftPiece
	Convert "shift and add" to PIECE: (zext(V) << 16) + zext(W) => concat(V,W) More...

class	RuleCollapseConstants
	Collapse constant expressions. More...

class	RuleTransformCpool
	Transform CPOOLREF operations by looking up the value in the constant pool. More...

class	RulePropagateCopy
	Propagate the input of a COPY to all the places that read the output. More...

class	Rule2Comp2Mult
	Eliminate INT_2COMP: `-V => V * -1` More...

class	RuleCarryElim
	Transform INT_CARRY using a constant: `carry(V,c) => -c <= V` More...

class	RuleSub2Add
	Eliminate INT_SUB: `V - W => V + W * -1` More...

class	RuleXorCollapse
	Eliminate INT_XOR in comparisons: `(V ^ W) == 0 => V == W` More...

class	RuleAddMultCollapse
	Collapse constants in an additive or multiplicative expression. More...

class	RuleLoadVarnode
	Convert LOAD operations using a constant offset to COPY. More...

class	RuleStoreVarnode
	Convert STORE operations using a constant offset to COPY. More...

class	RuleSubExtComm
	Commute SUBPIECE and INT_ZEXT: `sub(zext(V),c) => zext(sub(V,c))` More...

class	RuleSubCommute
	Commute SUBPIECE operations with earlier operations where possible. More...

class	RuleConcatCommute
	Commute PIECE with INT_AND, INT_OR, and INT_XOR. More...

class	RuleConcatZext
	Commute PIECE with INT_ZEXT: `concat(zext(V),W) => zext(concat(V,W))` More...

class	RuleZextCommute
	Commute INT_ZEXT with INT_RIGHT: `zext(V) >> W => zext(V >> W)` More...

class	RuleZextShiftZext
	Simplify multiple INT_ZEXT operations: `zext( zext(V) << c ) => zext(V) << c` More...

class	RuleShiftAnd
	Eliminate any INT_AND when the bits it zeroes out are discarded by a shift. More...

class	RuleConcatZero
	Simplify concatenation with zero: `concat(V,0) => zext(V) << c` More...

class	RuleConcatLeftShift
	Simplify concatenation of extended value: `concat(V, zext(W) << c) => concat( concat(V,W), 0)` More...

class	RuleSubZext
	Simplify INT_ZEXT applied to SUBPIECE expressions. More...

class	RuleSubCancel
	Simplify composition of SUBPIECE with INT_ZEXT or INT_SEXT. More...

class	RuleShiftSub
	Simplify SUBPIECE applied to INT_LEFT: `sub( V << 8*c, c) => sub(V,0)` More...

class	RuleHumptyDumpty
	Simplify break and rejoin: `concat( sub(V,c), sub(V,0) ) => V` More...

class	RuleDumptyHump
	Simplify join and break apart: `sub( concat(V,W), c) => sub(W,c)` More...

class	RuleHumptyOr
	Simplify masked pieces INT_ORed together: `(V & ff00) \| (V & 00ff) => V` More...

class	RuleEmbed
	Simplify PIECE intended as embedding: `concat(V, sub(W,0)) => W & 0xff \| (zext(W) << 8)` More...

class	RuleSwitchSingle
	Convert BRANCHIND with only one computed destination to a BRANCH. More...

class	RuleCondNegate
	Flip conditions to match structuring cues. More...

class	RuleBoolNegate
	Apply a set of identities involving BOOL_NEGATE. More...

class	RuleLess2Zero
	Simplify INT_LESS applied to extremal constants. More...

class	RuleLessEqual2Zero
	Simplify INT_LESSEQUAL applied to extremal constants. More...

class	RuleSLess2Zero
	Simplify INT_SLESS applied to 0 or -1. More...

class	RuleEqual2Zero
	Simplify INT_EQUAL applied to 0: `0 == V + W * -1 => V == W or 0 == V + c => V == -c` More...

class	RuleEqual2Constant
	Simplify INT_EQUAL applied to arithmetic expressions. More...

class	RulePtrArith
	Transform pointer arithmetic. More...

class	RuleStructOffset0
	Convert a LOAD or STORE to the first element of a structure to a PTRSUB. More...

class	RulePushPtr
	Push a Varnode with known pointer data-type to the bottom of its additive expression. More...

class	RulePtraddUndo
	Remove PTRADD operations with mismatched data-type information. More...

class	RulePtrsubUndo
	Remove PTRSUB operations with mismatched data-type information. More...

class	RuleMultNegOne
	Cleanup: Convert INT_2COMP from INT_MULT: `V * -1 => -V` More...

class	RuleAddUnsigned
	Cleanup: Convert INT_ADD of constants to INT_SUB: `V + 0xff... => V - 0x00...` More...

class	Rule2Comp2Sub
	Cleanup: Convert INT_ADD back to INT_SUB: `V + -W ==> V - W` More...

class	RuleSubRight
	Cleanup: Convert truncation to cast: `sub(V,c) => sub(V>>c*8,0)` More...

class	RulePtrsubCharConstant
	Cleanup: Set-up to print string constants. More...

class	RuleSubNormal
	Pull-back SUBPIECE through INT_RIGHT and INT_SRIGHT. More...

class	RulePositiveDiv
	Signed division of positive values is unsigned division. More...

class	RuleDivTermAdd
	Simplify expressions associated with optimized division expressions. More...

class	RuleDivTermAdd2
	Simplify another expression associated with optimized division. More...

class	RuleDivOpt
	Convert INT_MULT and shift forms into INT_DIV or INT_SDIV. More...

class	RuleSignDiv2
	Convert INT_SRIGHT form into INT_SDIV: `(V + -1*(V s>> 31)) s>> 1 => V s/ 2` More...

class	RuleSignForm
	Normalize sign extraction: `sub(sext(V),c) => V s>> 31` More...

class	RuleSignNearMult
	Simplify division form: `(V + (V s>> 0x1f)>>(32-n)) & (-1<<n) => (V s/ 2^n) * 2^n` More...

class	RuleModOpt
	Simplify expressions that optimize INT_REM and INT_SREM. More...

class	RuleSegment
	Propagate constants through a SEGMENTOP. More...

class	RuleSubvarAnd
	Perform SubVariableFlow analysis triggered by INT_AND. More...

class	RuleSubvarSubpiece
	Perform SubVariableFlow analysis triggered by SUBPIECE. More...

class	RuleSplitFlow
	Try to detect and split artificially joined Varnodes. More...

class	RulePtrFlow
	Mark Varnode and PcodeOp objects that are carrying or operating on pointers. More...

class	RuleSubvarCompZero
	Perform SubvariableFlow analysis triggered by testing of a single bit. More...

class	RuleSubvarShift
	Perform SubvariableFlow analysis triggered by INT_RIGHT. More...

class	RuleSubvarZext
	Perform SubvariableFlow analysis triggered by INT_ZEXT. More...

class	RuleSubvarSext
	Perform SubvariableFlow analysis triggered by INT_SEXT. More...

class	RuleSubfloatConvert
	Perform SubfloatFlow analysis triggered by FLOAT_FLOAT2FLOAT. More...

class	RuleNegateNegate
	Simplify INT_NEGATE chains: `~~V => V` More...

class	RuleConditionalMove
	Simplify various conditional move situations. More...

class	RuleConditionalMove::BoolExpress
	Class for categorizing and rebuilding a boolean expression. More...

class	RuleFloatCast
	Replace (casttosmall)(casttobig)V with identity or with single cast. More...

class	RuleIgnoreNan
	Treat FLOAT_NAN as always evaluating to false. More...

class	RuleFuncPtrEncoding
	Eliminate ARM/THUMB style masking of the low order bits on function pointers. More...

class	RuleThreeWayCompare
	Simplify expressions involving three-way comparisons. More...

class	RulePopcountBoolXor
	Simplify boolean expressions that are combined through POPCOUNT. More...

class	RulePiecePathology
	Search for concatenations with unlikely things to inform return/parameter consumption calculation. More...

class	RuleXorSwap

Detailed Description

This is the basic set of transformation Rule objects.

Each Rule triggers on a specific localized data-flow configuration. They are generally applied simultaneously from a pool (see ActionPool) and can interact with each other to produce an emergent transformation. The Rules are applied repeatedly until no Rule can make any additional transformations.

Classes

Detailed Description