Class for splitting larger registers holding smaller logical lanes. More...

#include <transform.hh>

Inheritance diagram for TransformManager:

[legend]

Public Member Functions
virtual	~TransformManager (void)
	Destructor.

virtual bool	preserveAddress (Varnode *vn, int4 bitSize, int4 lsbOffset) const
	Should the address of the given Varnode be preserved when constructing a piece. More...

void	clearVarnodeMarks (void)
	Clear mark for all Varnodes in the map.

TransformVar *	newPreexistingVarnode (Varnode *vn)
	Make placeholder for preexisting Varnode. More...

TransformVar *	newUnique (int4 size)
	Make placeholder for new unique space Varnode. More...

TransformVar *	newConstant (int4 size, int4 lsbOffset, uintb val)
	Make placeholder for constant Varnode. More...

TransformVar *	newIop (Varnode *vn)
	Make placeholder for special iop constant. More...

TransformVar *	newPiece (Varnode *vn, int4 bitSize, int4 lsbOffset)
	Make placeholder for piece of a Varnode. More...

TransformVar *	newSplit (Varnode *vn, const LaneDescription &description)
	Create placeholder nodes splitting a Varnode into its lanes. More...

TransformVar *	newSplit (Varnode *vn, const LaneDescription &description, int4 numLanes, int4 startLane)
	Create placeholder nodes splitting a Varnode into a subset of lanes in the given description. More...

TransformOp *	newOpReplace (int4 numParams, OpCode opc, PcodeOp *replace)
	Create a new placeholder op intended to replace an existing op. More...

TransformOp *	newOp (int4 numParams, OpCode opc, TransformOp *follow)
	Create a new placeholder op that will not replace an existing op. More...

TransformOp *	newPreexistingOp (int4 numParams, OpCode opc, PcodeOp *originalOp)
	Create a new placeholder op for an existing PcodeOp. More...

TransformVar *	getPreexistingVarnode (Varnode *vn)
	Get (or create) placeholder for preexisting Varnode. More...

TransformVar *	getPiece (Varnode *vn, int4 bitSize, int4 lsbOffset)
	Get (or create) placeholder piece. More...

TransformVar *	getSplit (Varnode *vn, const LaneDescription &description)
	Find (or create) placeholder nodes splitting a Varnode into its lanes. More...

TransformVar *	getSplit (Varnode *vn, const LaneDescription &description, int4 numLanes, int4 startLane)
	Find (or create) placeholder nodes splitting a Varnode into a subset of lanes from a description. More...

void	opSetInput (TransformOp rop, TransformVar rvn, int4 slot)
	Mark given variable as input to given op. More...

void	opSetOutput (TransformOp rop, TransformVar rvn)
	Mark given variable as output of given op. More...

void	apply (void)
	Apply the full transform to the function.

Static Public Member Functions
static bool	preexistingGuard (int4 slot, TransformVar *rvn)
	Should newPreexistingOp be called. More...

Detailed Description

Class for splitting larger registers holding smaller logical lanes.

Given a starting Varnode in the data-flow, look for evidence of the Varnode being interpreted as disjoint logical values concatenated together (lanes). If the interpretation is consistent for data-flow involving the Varnode, split Varnode and data-flow into explicit operations on the lanes.

Member Function Documentation

◆ getPiece()

TransformVar * TransformManager::getPiece	(	Varnode *	vn,
		int4	bitSize,
		int4	lsbOffset
	)

Get (or create) placeholder piece.

Given a big Varnode, find the placeholder corresponding to the logical value given by a size and significance offset. If it doesn't exist, create it.

Parameters

vn	is the big Varnode containing the logical value
bitSize	is the size of the logical value in bytes
lsbOffset	is the signficance offset of the logical value within the Varnode

Returns: the found/created placeholder

◆ getPreexistingVarnode()

TransformVar * TransformManager::getPreexistingVarnode ( Varnode * vn )

Get (or create) placeholder for preexisting Varnode.

Check if a placeholder node was created for the preexisting Varnode for, otherwise create a new one.

Parameters

vn	is the preexisting Varnode to find a placeholder for

Returns: the placeholder node

◆ getSplit() [1/2]

TransformVar * TransformManager::getSplit	(	Varnode *	vn,
		const LaneDescription &	description
	)

Find (or create) placeholder nodes splitting a Varnode into its lanes.

Given a big Varnode and a lane description, look up placeholders for all its explicit pieces. If they don't exist, create them.

Parameters

vn	is the big Varnode to split
description	shows how the big Varnode will be split

Returns: an array of the TransformVar placeholders from least to most significant

◆ getSplit() [2/2]

TransformVar * TransformManager::getSplit	(	Varnode *	vn,
		const LaneDescription &	description,
		int4	numLanes,
		int4	startLane
	)

Find (or create) placeholder nodes splitting a Varnode into a subset of lanes from a description.

Given a big Varnode and a specific subset of a lane description, look up placeholders for all the explicit pieces. If they don't exist, create them.

Parameters

vn	is the big Varnode to split
description	describes all the possible lanes
numLanes	is the number of lanes in the subset
startLane	is the starting (least significant) lane in the subset

Returns: an array of the TransformVar placeholders from least to most significant

◆ newConstant()

TransformVar * TransformManager::newConstant	(	int4	size,
		int4	lsbOffset,
		uintb	val
	)

Make placeholder for constant Varnode.

Create a new constant in the transform view. A piece of an existing constant can be created by giving the existing value and the least significant offset.

Parameters

size	is the size in bytes of the new constant
lsbOffset	is the number of bits to strip off of the existing value
val	is the value of the constant

Returns: the new placeholder node

◆ newIop()

TransformVar * TransformManager::newIop ( Varnode * vn )

Make placeholder for special iop constant.

Used for creating INDIRECT placeholders.

Parameters

vn	is the original iop parameter to the INDIRECT

Returns: the new placeholder node

◆ newOp()

TransformOp * TransformManager::newOp	(	int4	numParams,
		OpCode	opc,
		TransformOp *	follow
	)

Create a new placeholder op that will not replace an existing op.

An uninitialized placeholder for the new op is created. When (if) the new op is created it will not replace an existing op. The op that follows it must be given.

Parameters

numParams	is the number of Varnode inputs intended for the new op
opc	is the opcode of the new op
follow	is the placeholder for the op that follow the new op when it is created

Returns: the new placeholder node

◆ newOpReplace()

TransformOp * TransformManager::newOpReplace	(	int4	numParams,
		OpCode	opc,
		PcodeOp *	replace
	)

Create a new placeholder op intended to replace an existing op.

An uninitialized placeholder for the new op is created.

Parameters

numParams	is the number of Varnode inputs intended for the new op
opc	is the opcode of the new op
replace	is the existing op the new op will replace

Returns: the new placeholder node

◆ newPiece()

TransformVar * TransformManager::newPiece	(	Varnode *	vn,
		int4	bitSize,
		int4	lsbOffset
	)

Make placeholder for piece of a Varnode.

Given a single logical value within a larger Varnode, create a placeholder for that logical value.

Parameters

vn	is the large Varnode
bitSize	is the size of the logical value in bits
lsbOffset	is the number of least significant bits of the Varnode dropped from the value

Returns: the placeholder variable

◆ newPreexistingOp()

TransformOp * TransformManager::newPreexistingOp	(	int4	numParams,
		OpCode	opc,
		PcodeOp *	originalOp
	)

Create a new placeholder op for an existing PcodeOp.

An uninitialized placeholder for the existing op is created. When applied, this causes the op to be transformed as described by the placeholder, changing its opcode and inputs. The output however is unaffected.

Parameters

numParams	is the number of Varnode inputs intended for the transformed op
opc	is the opcode of the transformed op
originalOp	is the preexisting PcodeOp

Returns: the new placeholder node

◆ newPreexistingVarnode()

TransformVar * TransformManager::newPreexistingVarnode ( Varnode * vn )

Make placeholder for preexisting Varnode.

Parameters

vn	is the preexisting Varnode to create a placeholder for

Returns: the new placeholder node

◆ newSplit() [1/2]

TransformVar * TransformManager::newSplit	(	Varnode *	vn,
		const LaneDescription &	description
	)

Create placeholder nodes splitting a Varnode into its lanes.

Given a big Varnode and a lane description, create placeholders for all the explicit pieces that the big Varnode will be split into.

Parameters

vn	is the big Varnode to split
description	shows how the big Varnode will be split

Returns: an array of the new TransformVar placeholders from least to most significant

◆ newSplit() [2/2]

TransformVar * TransformManager::newSplit	(	Varnode *	vn,
		const LaneDescription &	description,
		int4	numLanes,
		int4	startLane
	)

Create placeholder nodes splitting a Varnode into a subset of lanes in the given description.

Given a big Varnode and specific subset of a lane description, create placeholders for all the explicit pieces that the big Varnode will be split into.

Parameters

vn	is the big Varnode to split
description	gives a list of potentional lanes
numLanes	is the number of lanes in the subset
startLane	is the starting (least significant) lane in the subset

Returns: an array of the new TransformVar placeholders from least to most significant

◆ newUnique()

TransformVar * TransformManager::newUnique ( int4 size )

Make placeholder for new unique space Varnode.

Parameters

size	is the size in bytes of the new unique Varnode

Returns: the new placeholder node

◆ opSetInput()

void TransformManager::opSetInput	(	TransformOp *	rop,
		TransformVar *	rvn,
		int4	slot
	)

inline

Mark given variable as input to given op.

Parameters

rop	is the given placeholder op whose input is set
rvn	is the placeholder variable to set
slot	is the input position to set

◆ opSetOutput()

void TransformManager::opSetOutput	(	TransformOp *	rop,
		TransformVar *	rvn
	)

inline

Mark given variable as output of given op.

Establish that the given op produces the given var as output. Mark both the output field of the TransformOp and the def field of the TransformVar.

Parameters

rop	is the given op
rvn	is the given variable

◆ preexistingGuard()

bool TransformManager::preexistingGuard	(	int4	slot,
		TransformVar *	rvn
	)

inlinestatic

Should newPreexistingOp be called.

Varnode marking prevents duplicate TransformOp (and TransformVar) records from getting created, except in the case of a preexisting PcodeOp with 2 (or more) non-constant inputs. Because the op is preexisting the output Varnode doesn't get marked, and the op will be visited for each input. This method determines when the TransformOp object should be created, with the goal of creating it exactly once even though the op is visited more than once. It currently assumes the PcodeOp is binary, and the slot along which the op is currently visited is passed in, along with the TransformVar for the other input. It returns true if the TransformOp should be created.

Parameters

slot	is the incoming slot along which the op is visited
rvn	is the other input

◆ preserveAddress()

bool TransformManager::preserveAddress	(	Varnode *	vn,
		int4	bitSize,
		int4	lsbOffset
	)		const

virtual

Should the address of the given Varnode be preserved when constructing a piece.

A new Varnode will be created that represents a logical piece of the given Varnode. This routine determines whether the new Varnode should be constructed using storage which overlaps the given Varnode. It returns true if overlapping storage should be used, false if the new Varnode should be constructed as a unique temporary.

Parameters

vn	is the given Varnode
bitSize	is the logical size of the Varnode piece being constructed
lsbOffset	is the least significant bit position of the logical value within the given Varnode

Returns: true if overlapping storage should be used in construction

Reimplemented in SubfloatFlow.

The documentation for this class was generated from the following files:

transform.hh
transform.cc

Public Member Functions

Static Public Member Functions

Detailed Description

Member Function Documentation

◆ getPiece()

◆ getPreexistingVarnode()

◆ getSplit() [1/2]

◆ getSplit() [2/2]

◆ newConstant()

◆ newIop()

◆ newOp()

◆ newOpReplace()

◆ newPiece()

◆ newPreexistingOp()

◆ newPreexistingVarnode()

◆ newSplit() [1/2]

◆ newSplit() [2/2]

◆ newUnique()

◆ opSetInput()

◆ opSetOutput()

◆ preexistingGuard()

◆ preserveAddress()