Description

Analysis to find variable locations.

See namespace for more information and caveats.

Definition at line 23 of file VariableFinder.h.

#include <Rose/BinaryAnalysis/Variables/VariableFinder.h>

Classes
struct	Settings
	Settings that control this analysis. More...

Public Types

using	Ptr = VariableFinderPtr
	Shared ownership pointer for VariableFinder.

using	ConstPtr = VariableFinderConstPtr
	Shared ownership pointer for VariableFinder.

Public Member Functions
GlobalVariables	findGlobalVariables (const Partitioner2::PartitionerConstPtr &)
	Find global variables.

bool	isCached (const Partitioner2::FunctionPtr &)
	Test whether local variable information is cached.

StackFrame	detectFrameAttributes (const Partitioner2::PartitionerConstPtr &, const Partitioner2::FunctionPtr &, StackVariable::Boundaries &)
	Figure out attributes describing the stack frame for the specified function.

AddressToAddresses	findGlobalVariableVas (const Partitioner2::PartitionerConstPtr &)
	Find global variable addresses.

std::set< Address >	findConstants (const SymbolicExpression::Ptr &)
	Find address constants in an expression.

std::set< Address >	findConstants (SgAsmInstruction *)
	Find constants syntactically in an instruction.

std::set< SymbolicExpression::Ptr >	getMemoryAddresses (const InstructionSemantics::BaseSemantics::MemoryCellStatePtr &)
	Find addresses in memory state.

std::set< Address >	findAddressConstants (const InstructionSemantics::BaseSemantics::MemoryCellStatePtr &)
	Find constants in memory.

void	removeOutliers (const StackFrame &, StackVariable::Boundaries &sortedBoundaries)
	Remove boundaries that are outside a stack frame.


const Settings &	settings () const
	Settings for this analysis.

Settings &	settings ()
	Settings for this analysis.


StackVariables	findStackVariables (const Partitioner2::PartitionerConstPtr &, const Partitioner2::FunctionPtr &)
	Find local variables in a function.

StackVariables	findStackVariables (const Partitioner2::PartitionerConstPtr &, SgAsmInstruction *)
	Find local variables in a function.


void	evict (const Partitioner2::FunctionPtr &)
	Removed cached information.

void	evict (const Partitioner2::PartitionerConstPtr &)
	Removed cached information.

Static Public Member Functions
static Ptr	instance (const Settings &settings=Settings())
	Allocating constructor.

static Sawyer::CommandLine::SwitchGroup	commandLineSwitches (Settings &)
	Command-line switches for analysis settings.

static bool	regionContainsInstructions (const Partitioner2::PartitionerConstPtr &, const AddressInterval &)
	True if memory region contains any decoded instructions.

static bool	regionIsFullyMapped (const Partitioner2::PartitionerConstPtr &, const AddressInterval &)
	True if memory region is fully mapped.

static bool	regionIsFullyReadWrite (const Partitioner2::PartitionerConstPtr &, const AddressInterval &)
	True if memory region is fully mapped with read and write access.

Protected Member Functions
	VariableFinder (const Settings &)

Member Typedef Documentation

◆ Ptr

using Rose::BinaryAnalysis::Variables::VariableFinder::Ptr = VariableFinderPtr

Shared ownership pointer for VariableFinder.

Definition at line 37 of file VariableFinder.h.

◆ ConstPtr

using Rose::BinaryAnalysis::Variables::VariableFinder::ConstPtr = VariableFinderConstPtr

Shared ownership pointer for VariableFinder.

Definition at line 38 of file VariableFinder.h.

Member Function Documentation

◆ settings() [1/2]

const Settings & Rose::BinaryAnalysis::Variables::VariableFinder::settings ( ) const

inline

Settings for this analysis.

Definition at line 56 of file VariableFinder.h.

◆ settings() [2/2]

Settings & Rose::BinaryAnalysis::Variables::VariableFinder::settings ( )

inline

Settings for this analysis.

Definition at line 57 of file VariableFinder.h.

◆ commandLineSwitches()

static Sawyer::CommandLine::SwitchGroup Rose::BinaryAnalysis::Variables::VariableFinder::commandLineSwitches ( Settings & )

static

Command-line switches for analysis settings.

This function captures a reference to the specified settings so that when the command-line is parsed later, those settings are modified.

◆ findStackVariables() [1/2]

StackVariables Rose::BinaryAnalysis::Variables::VariableFinder::findStackVariables	(	const Partitioner2::PartitionerConstPtr &	,
		const Partitioner2::FunctionPtr &
	)

Find local variables in a function.

Analyzes the given function to find the local (stack) variables, caches and returns the list. If this information is already cached, then this method just returns the cached value.

The second argument can be either a function or an instruction. When it's an instruction, we arbitrarily choose one of the functions that owns the instruction. Usually each instruction is owned by only one function, but there are exceptions.

◆ findStackVariables() [2/2]

StackVariables Rose::BinaryAnalysis::Variables::VariableFinder::findStackVariables	(	const Partitioner2::PartitionerConstPtr &	,
		SgAsmInstruction *
	)

Find local variables in a function.

Analyzes the given function to find the local (stack) variables, caches and returns the list. If this information is already cached, then this method just returns the cached value.

The second argument can be either a function or an instruction. When it's an instruction, we arbitrarily choose one of the functions that owns the instruction. Usually each instruction is owned by only one function, but there are exceptions.

◆ findGlobalVariables()

GlobalVariables Rose::BinaryAnalysis::Variables::VariableFinder::findGlobalVariables ( const Partitioner2::PartitionerConstPtr & )

Find global variables.

Finds global variables by examining all functions represented by the given partitioner. Global variables can be found only if they're read or written by some code, and not through a pointer. For example, this method detects variable g1 but not g2 in the following compiled C code:

int g1, g2;
 
int foo() {
    return g1;
}
 
int bar(int *ptr) {
    return *ptr; // no static address even if ptr points to g2
}

If previous results are already cached then they're returned, otherwise new results are computed, cached, and returned.

◆ evict() [1/2]

void Rose::BinaryAnalysis::Variables::VariableFinder::evict ( const Partitioner2::FunctionPtr & )

Removed cached information.

If a function is supplied as an argument, remove information cached by this analysis for that function. If a partitioner is specified then remove information from all functions.

◆ evict() [2/2]

void Rose::BinaryAnalysis::Variables::VariableFinder::evict ( const Partitioner2::PartitionerConstPtr & )

Removed cached information.

If a function is supplied as an argument, remove information cached by this analysis for that function. If a partitioner is specified then remove information from all functions.

◆ isCached()

bool Rose::BinaryAnalysis::Variables::VariableFinder::isCached ( const Partitioner2::FunctionPtr & )

Test whether local variable information is cached.

Returns true if findStackVariables has been run for the specified function and the results are currently cached in that function.

◆ findGlobalVariableVas()

AddressToAddresses Rose::BinaryAnalysis::Variables::VariableFinder::findGlobalVariableVas ( const Partitioner2::PartitionerConstPtr & )

Find global variable addresses.

Returns a list of addresses that are possibly the beginning of global variables. We're only able to find global variables that are referenced by instructions that read or write to the variable. If the global variable is an array then one of two things happen:

If the array elements are only accessed with indices that are unknown statically, then the address of the beginning of the array is returned. This applies to C code like:

int get(int i) {
    return array[i];
}
int sum(int n) {
    int s = 0;
    for (int i=0; i < n; ++i)
        s += array[i];
    return s;
}

If the array elements are accessed with constant indices, then it's impossible to distinguish between accessing an array with constant indexes and accessing a non-array variable. This applies to C code like:

int get() {
    return array[3];
}
int sum() {
    int s = 0;
    for (int i=0; i < 4; ++i) // assume loop unrolling optimization
        s += array[i];
    return s;
}

◆ findConstants()

std::set< Address > Rose::BinaryAnalysis::Variables::VariableFinder::findConstants ( const SymbolicExpression::Ptr & )

Find address constants in an expression.

Given a symbolic expression, return all the constants that appear in it that have a potential for being addresses.

◆ getMemoryAddresses()

std::set< SymbolicExpression::Ptr > Rose::BinaryAnalysis::Variables::VariableFinder::getMemoryAddresses ( const InstructionSemantics::BaseSemantics::MemoryCellStatePtr & )

Find addresses in memory state.

Given a cell-based symbolic memory state, return all the memory addresses that appear in it.

◆ findAddressConstants()

std::set< Address > Rose::BinaryAnalysis::Variables::VariableFinder::findAddressConstants ( const InstructionSemantics::BaseSemantics::MemoryCellStatePtr & )

Find constants in memory.

Given an cell-based symbolic memory state, return all constants that appear in the cell addresses.

◆ removeOutliers()

void Rose::BinaryAnalysis::Variables::VariableFinder::removeOutliers	(	const StackFrame &	,
		StackVariable::Boundaries &	sortedBoundaries
	)

Remove boundaries that are outside a stack frame.

If the frame's lowest address is known, then boundaries that begin before the frame are removed. Except if there is no boundary at the beginning of the frame, then the greatest boundary before the frame is moved to the beginning of the frame instead of being removed entirely.

If the frame's upper address is known, then any boundary above that address is removed from the list.

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

VariableFinder.h