repo stringlengths 7 55 | path stringlengths 4 223 | func_name stringlengths 1 134 | original_string stringlengths 75 104k | language stringclasses 1
value | code stringlengths 75 104k | code_tokens listlengths 19 28.4k | docstring stringlengths 1 46.9k | docstring_tokens listlengths 1 1.97k | sha stringlengths 40 40 | url stringlengths 87 315 | partition stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
angr/angr | angr/analyses/backward_slice.py | BackwardSlice.annotated_cfg | def annotated_cfg(self, start_point=None):
"""
Returns an AnnotatedCFG based on slicing result.
"""
# TODO: Support context-sensitivity
targets = [ ]
for simrun, stmt_idx in self._targets:
targets.append((simrun.addr, stmt_idx))
l.debug("Initializi... | python | def annotated_cfg(self, start_point=None):
"""
Returns an AnnotatedCFG based on slicing result.
"""
# TODO: Support context-sensitivity
targets = [ ]
for simrun, stmt_idx in self._targets:
targets.append((simrun.addr, stmt_idx))
l.debug("Initializi... | [
"def",
"annotated_cfg",
"(",
"self",
",",
"start_point",
"=",
"None",
")",
":",
"# TODO: Support context-sensitivity",
"targets",
"=",
"[",
"]",
"for",
"simrun",
",",
"stmt_idx",
"in",
"self",
".",
"_targets",
":",
"targets",
".",
"append",
"(",
"(",
"simrun... | Returns an AnnotatedCFG based on slicing result. | [
"Returns",
"an",
"AnnotatedCFG",
"based",
"on",
"slicing",
"result",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L168-L202 | train |
angr/angr | angr/analyses/backward_slice.py | BackwardSlice.is_taint_related_to_ip | def is_taint_related_to_ip(self, simrun_addr, stmt_idx, taint_type, simrun_whitelist=None):
"""
Query in taint graph to check if a specific taint will taint the IP in the future or not.
The taint is specified with the tuple (simrun_addr, stmt_idx, taint_type).
:param simrun_addr: ... | python | def is_taint_related_to_ip(self, simrun_addr, stmt_idx, taint_type, simrun_whitelist=None):
"""
Query in taint graph to check if a specific taint will taint the IP in the future or not.
The taint is specified with the tuple (simrun_addr, stmt_idx, taint_type).
:param simrun_addr: ... | [
"def",
"is_taint_related_to_ip",
"(",
"self",
",",
"simrun_addr",
",",
"stmt_idx",
",",
"taint_type",
",",
"simrun_whitelist",
"=",
"None",
")",
":",
"if",
"simrun_whitelist",
"is",
"None",
":",
"simrun_whitelist",
"=",
"set",
"(",
")",
"if",
"type",
"(",
"s... | Query in taint graph to check if a specific taint will taint the IP in the future or not.
The taint is specified with the tuple (simrun_addr, stmt_idx, taint_type).
:param simrun_addr: Address of the SimRun.
:param stmt_idx: Statement ID.
:param taint_type: T... | [
"Query",
"in",
"taint",
"graph",
"to",
"check",
"if",
"a",
"specific",
"taint",
"will",
"taint",
"the",
"IP",
"in",
"the",
"future",
"or",
"not",
".",
"The",
"taint",
"is",
"specified",
"with",
"the",
"tuple",
"(",
"simrun_addr",
"stmt_idx",
"taint_type",
... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L204-L245 | train |
angr/angr | angr/analyses/backward_slice.py | BackwardSlice._construct | def _construct(self, targets, control_flow_slice=False):
"""
Construct a dependency graph based on given parameters.
:param targets: A list of tuples like (CFGNode, statement ID)
:param control_flow_slice: Is the backward slicing only depends on CFG or not.
"""
... | python | def _construct(self, targets, control_flow_slice=False):
"""
Construct a dependency graph based on given parameters.
:param targets: A list of tuples like (CFGNode, statement ID)
:param control_flow_slice: Is the backward slicing only depends on CFG or not.
"""
... | [
"def",
"_construct",
"(",
"self",
",",
"targets",
",",
"control_flow_slice",
"=",
"False",
")",
":",
"if",
"control_flow_slice",
":",
"simruns",
"=",
"[",
"r",
"for",
"r",
",",
"_",
"in",
"targets",
"]",
"self",
".",
"_construct_control_flow_slice",
"(",
"... | Construct a dependency graph based on given parameters.
:param targets: A list of tuples like (CFGNode, statement ID)
:param control_flow_slice: Is the backward slicing only depends on CFG or not. | [
"Construct",
"a",
"dependency",
"graph",
"based",
"on",
"given",
"parameters",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L291-L304 | train |
angr/angr | angr/analyses/backward_slice.py | BackwardSlice._construct_control_flow_slice | def _construct_control_flow_slice(self, simruns):
"""
Build a slice of the program without considering the effect of data dependencies.
This is an incorrect hack, but it should work fine with small programs.
:param simruns: A list of SimRun targets. You probably wanna get it from the CF... | python | def _construct_control_flow_slice(self, simruns):
"""
Build a slice of the program without considering the effect of data dependencies.
This is an incorrect hack, but it should work fine with small programs.
:param simruns: A list of SimRun targets. You probably wanna get it from the CF... | [
"def",
"_construct_control_flow_slice",
"(",
"self",
",",
"simruns",
")",
":",
"# TODO: Support context-sensitivity!",
"if",
"self",
".",
"_cfg",
"is",
"None",
":",
"l",
".",
"error",
"(",
"'Please build CFG first.'",
")",
"cfg",
"=",
"self",
".",
"_cfg",
".",
... | Build a slice of the program without considering the effect of data dependencies.
This is an incorrect hack, but it should work fine with small programs.
:param simruns: A list of SimRun targets. You probably wanna get it from the CFG somehow. It must exist in the
CFG. | [
"Build",
"a",
"slice",
"of",
"the",
"program",
"without",
"considering",
"the",
"effect",
"of",
"data",
"dependencies",
".",
"This",
"is",
"an",
"incorrect",
"hack",
"but",
"it",
"should",
"work",
"fine",
"with",
"small",
"programs",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L306-L343 | train |
angr/angr | angr/analyses/backward_slice.py | BackwardSlice._construct_default | def _construct_default(self, targets):
"""
Create a backward slice from a specific statement in a specific block. This is done by traverse the CFG
backwards, and mark all tainted statements based on dependence graphs (CDG and DDG) provided initially. The
traversal terminated when we reac... | python | def _construct_default(self, targets):
"""
Create a backward slice from a specific statement in a specific block. This is done by traverse the CFG
backwards, and mark all tainted statements based on dependence graphs (CDG and DDG) provided initially. The
traversal terminated when we reac... | [
"def",
"_construct_default",
"(",
"self",
",",
"targets",
")",
":",
"# TODO: Support context-sensitivity",
"l",
".",
"debug",
"(",
"\"Constructing a default backward program slice\"",
")",
"self",
".",
"taint_graph",
"=",
"networkx",
".",
"DiGraph",
"(",
")",
"taints"... | Create a backward slice from a specific statement in a specific block. This is done by traverse the CFG
backwards, and mark all tainted statements based on dependence graphs (CDG and DDG) provided initially. The
traversal terminated when we reach the entry point, or when there is no unresolved dependenc... | [
"Create",
"a",
"backward",
"slice",
"from",
"a",
"specific",
"statement",
"in",
"a",
"specific",
"block",
".",
"This",
"is",
"done",
"by",
"traverse",
"the",
"CFG",
"backwards",
"and",
"mark",
"all",
"tainted",
"statements",
"based",
"on",
"dependence",
"gra... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L345-L421 | train |
angr/angr | angr/analyses/backward_slice.py | BackwardSlice._find_exits | def _find_exits(self, src_block, target_block):
"""
Source block has more than one exit, and through some of those exits, the control flow can eventually go to
the target block. This method returns exits that lead to the target block.
:param src_block: The block that has multiple ... | python | def _find_exits(self, src_block, target_block):
"""
Source block has more than one exit, and through some of those exits, the control flow can eventually go to
the target block. This method returns exits that lead to the target block.
:param src_block: The block that has multiple ... | [
"def",
"_find_exits",
"(",
"self",
",",
"src_block",
",",
"target_block",
")",
":",
"# Enumerate all statements and find exit statements",
"# Since we don't have a state, we have to rely on the pyvex block instead of SimIRSB",
"# Just create the block from pyvex again - not a big deal",
"i... | Source block has more than one exit, and through some of those exits, the control flow can eventually go to
the target block. This method returns exits that lead to the target block.
:param src_block: The block that has multiple exits.
:param target_block: The target block to reach.
... | [
"Source",
"block",
"has",
"more",
"than",
"one",
"exit",
"and",
"through",
"some",
"of",
"those",
"exits",
"the",
"control",
"flow",
"can",
"eventually",
"go",
"to",
"the",
"target",
"block",
".",
"This",
"method",
"returns",
"exits",
"that",
"lead",
"to",... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L423-L491 | train |
angr/angr | angr/analyses/backward_slice.py | BackwardSlice._handle_control_dependence | def _handle_control_dependence(self, target_node):
"""
Based on control dependence graph, pick all exits (statements) that lead to the target.
:param target_node: A CFGNode instance.
:returns: A set of new tainted code locations.
"""
new_taints = set()
... | python | def _handle_control_dependence(self, target_node):
"""
Based on control dependence graph, pick all exits (statements) that lead to the target.
:param target_node: A CFGNode instance.
:returns: A set of new tainted code locations.
"""
new_taints = set()
... | [
"def",
"_handle_control_dependence",
"(",
"self",
",",
"target_node",
")",
":",
"new_taints",
"=",
"set",
"(",
")",
"# Query the CDG and figure out all control flow transitions to reach this target",
"cdg_guardians",
"=",
"self",
".",
"_cdg",
".",
"get_guardians",
"(",
"t... | Based on control dependence graph, pick all exits (statements) that lead to the target.
:param target_node: A CFGNode instance.
:returns: A set of new tainted code locations. | [
"Based",
"on",
"control",
"dependence",
"graph",
"pick",
"all",
"exits",
"(",
"statements",
")",
"that",
"lead",
"to",
"the",
"target",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L493-L559 | train |
angr/angr | angr/analyses/backward_slice.py | BackwardSlice._map_to_cfg | def _map_to_cfg(self):
"""
Map our current slice to CFG.
Based on self._statements_per_run and self._exit_statements_per_run, this method will traverse the CFG and
check if there is any missing block on the path. If there is, the default exit of that missing block will be
includ... | python | def _map_to_cfg(self):
"""
Map our current slice to CFG.
Based on self._statements_per_run and self._exit_statements_per_run, this method will traverse the CFG and
check if there is any missing block on the path. If there is, the default exit of that missing block will be
includ... | [
"def",
"_map_to_cfg",
"(",
"self",
")",
":",
"exit_statements_per_run",
"=",
"self",
".",
"chosen_exits",
"new_exit_statements_per_run",
"=",
"defaultdict",
"(",
"list",
")",
"while",
"len",
"(",
"exit_statements_per_run",
")",
":",
"for",
"block_address",
",",
"e... | Map our current slice to CFG.
Based on self._statements_per_run and self._exit_statements_per_run, this method will traverse the CFG and
check if there is any missing block on the path. If there is, the default exit of that missing block will be
included in the slice. This is because Slicecutor... | [
"Map",
"our",
"current",
"slice",
"to",
"CFG",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L561-L592 | train |
angr/angr | angr/analyses/backward_slice.py | BackwardSlice._pick_statement | def _pick_statement(self, block_address, stmt_idx):
"""
Include a statement in the final slice.
:param int block_address: Address of the basic block.
:param int stmt_idx: Statement ID.
"""
# TODO: Support context-sensitivity
# Sanity check
if n... | python | def _pick_statement(self, block_address, stmt_idx):
"""
Include a statement in the final slice.
:param int block_address: Address of the basic block.
:param int stmt_idx: Statement ID.
"""
# TODO: Support context-sensitivity
# Sanity check
if n... | [
"def",
"_pick_statement",
"(",
"self",
",",
"block_address",
",",
"stmt_idx",
")",
":",
"# TODO: Support context-sensitivity",
"# Sanity check",
"if",
"not",
"isinstance",
"(",
"block_address",
",",
"int",
")",
":",
"raise",
"AngrBackwardSlicingError",
"(",
"\"Invalid... | Include a statement in the final slice.
:param int block_address: Address of the basic block.
:param int stmt_idx: Statement ID. | [
"Include",
"a",
"statement",
"in",
"the",
"final",
"slice",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L594-L610 | train |
angr/angr | angr/analyses/backward_slice.py | BackwardSlice._pick_exit | def _pick_exit(self, block_address, stmt_idx, target_ips):
"""
Include an exit in the final slice.
:param block_address: Address of the basic block.
:param stmt_idx: ID of the exit statement.
:param target_ips: The target address of this exit statement.
"""... | python | def _pick_exit(self, block_address, stmt_idx, target_ips):
"""
Include an exit in the final slice.
:param block_address: Address of the basic block.
:param stmt_idx: ID of the exit statement.
:param target_ips: The target address of this exit statement.
"""... | [
"def",
"_pick_exit",
"(",
"self",
",",
"block_address",
",",
"stmt_idx",
",",
"target_ips",
")",
":",
"# TODO: Support context-sensitivity",
"tpl",
"=",
"(",
"stmt_idx",
",",
"target_ips",
")",
"if",
"tpl",
"not",
"in",
"self",
".",
"chosen_exits",
"[",
"block... | Include an exit in the final slice.
:param block_address: Address of the basic block.
:param stmt_idx: ID of the exit statement.
:param target_ips: The target address of this exit statement. | [
"Include",
"an",
"exit",
"in",
"the",
"final",
"slice",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L612-L625 | train |
angr/angr | angr/analyses/backward_slice.py | BackwardSlice._conditional_exits | def _conditional_exits(self, block_addr):
"""
Return a list of conditional statement exits with respect to a basic block.
:param block_addr: The address of the basic block.
:return: A list of statement IDs.
"""
vex_block = self.project.factory.block(block_ad... | python | def _conditional_exits(self, block_addr):
"""
Return a list of conditional statement exits with respect to a basic block.
:param block_addr: The address of the basic block.
:return: A list of statement IDs.
"""
vex_block = self.project.factory.block(block_ad... | [
"def",
"_conditional_exits",
"(",
"self",
",",
"block_addr",
")",
":",
"vex_block",
"=",
"self",
".",
"project",
".",
"factory",
".",
"block",
"(",
"block_addr",
")",
".",
"vex",
"lst",
"=",
"[",
"]",
"for",
"i",
",",
"stmt",
"in",
"enumerate",
"(",
... | Return a list of conditional statement exits with respect to a basic block.
:param block_addr: The address of the basic block.
:return: A list of statement IDs. | [
"Return",
"a",
"list",
"of",
"conditional",
"statement",
"exits",
"with",
"respect",
"to",
"a",
"basic",
"block",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L631-L646 | train |
angr/angr | angr/analyses/backward_slice.py | BackwardSlice._normalize_stmt_idx | def _normalize_stmt_idx(self, block_addr, stmt_idx):
"""
For each statement ID, convert 'default' to (last_stmt_idx+1)
:param block_addr: The block address.
:param stmt_idx: Statement ID.
:returns: New statement ID.
"""
if type(stmt_idx) is int:
... | python | def _normalize_stmt_idx(self, block_addr, stmt_idx):
"""
For each statement ID, convert 'default' to (last_stmt_idx+1)
:param block_addr: The block address.
:param stmt_idx: Statement ID.
:returns: New statement ID.
"""
if type(stmt_idx) is int:
... | [
"def",
"_normalize_stmt_idx",
"(",
"self",
",",
"block_addr",
",",
"stmt_idx",
")",
":",
"if",
"type",
"(",
"stmt_idx",
")",
"is",
"int",
":",
"return",
"stmt_idx",
"if",
"stmt_idx",
"==",
"DEFAULT_STATEMENT",
":",
"vex_block",
"=",
"self",
".",
"project",
... | For each statement ID, convert 'default' to (last_stmt_idx+1)
:param block_addr: The block address.
:param stmt_idx: Statement ID.
:returns: New statement ID. | [
"For",
"each",
"statement",
"ID",
"convert",
"default",
"to",
"(",
"last_stmt_idx",
"+",
"1",
")"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L648-L664 | train |
angr/angr | angr/analyses/backward_slice.py | BackwardSlice._last_branching_statement | def _last_branching_statement(statements):
"""
Search for the last branching exit, just like
# if (t12) { PUT(184) = 0xBADF00D:I64; exit-Boring }
and then taint the temp variable inside if predicate
"""
cmp_stmt_id = None
cmp_tmp_id = None
total_stmts = ... | python | def _last_branching_statement(statements):
"""
Search for the last branching exit, just like
# if (t12) { PUT(184) = 0xBADF00D:I64; exit-Boring }
and then taint the temp variable inside if predicate
"""
cmp_stmt_id = None
cmp_tmp_id = None
total_stmts = ... | [
"def",
"_last_branching_statement",
"(",
"statements",
")",
":",
"cmp_stmt_id",
"=",
"None",
"cmp_tmp_id",
"=",
"None",
"total_stmts",
"=",
"len",
"(",
"statements",
")",
"statements",
"=",
"reversed",
"(",
"statements",
")",
"for",
"stmt_rev_idx",
",",
"stmt",
... | Search for the last branching exit, just like
# if (t12) { PUT(184) = 0xBADF00D:I64; exit-Boring }
and then taint the temp variable inside if predicate | [
"Search",
"for",
"the",
"last",
"branching",
"exit",
"just",
"like",
"#",
"if",
"(",
"t12",
")",
"{",
"PUT",
"(",
"184",
")",
"=",
"0xBADF00D",
":",
"I64",
";",
"exit",
"-",
"Boring",
"}",
"and",
"then",
"taint",
"the",
"temp",
"variable",
"inside",
... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/backward_slice.py#L667-L683 | train |
angr/angr | angr/engines/soot/statements/base.py | SimSootStmt._get_bb_addr_from_instr | def _get_bb_addr_from_instr(self, instr):
"""
Returns the address of the methods basic block that contains the given
instruction.
:param instr: The index of the instruction (within the current method).
:rtype: SootAddressDescriptor
"""
current_method = self.state... | python | def _get_bb_addr_from_instr(self, instr):
"""
Returns the address of the methods basic block that contains the given
instruction.
:param instr: The index of the instruction (within the current method).
:rtype: SootAddressDescriptor
"""
current_method = self.state... | [
"def",
"_get_bb_addr_from_instr",
"(",
"self",
",",
"instr",
")",
":",
"current_method",
"=",
"self",
".",
"state",
".",
"addr",
".",
"method",
"try",
":",
"bb",
"=",
"current_method",
".",
"block_by_label",
"[",
"instr",
"]",
"except",
"KeyError",
":",
"l... | Returns the address of the methods basic block that contains the given
instruction.
:param instr: The index of the instruction (within the current method).
:rtype: SootAddressDescriptor | [
"Returns",
"the",
"address",
"of",
"the",
"methods",
"basic",
"block",
"that",
"contains",
"the",
"given",
"instruction",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/engines/soot/statements/base.py#L41-L57 | train |
angr/angr | angr/state_plugins/fast_memory.py | SimFastMemory._handle_uninitialized_read | def _handle_uninitialized_read(self, addr, inspect=True, events=True):
"""
The default uninitialized read handler. Returns symbolic bytes.
"""
if self._uninitialized_read_handler is None:
v = self.state.solver.Unconstrained("%s_%s" % (self.id, addr), self.width*self.state.arc... | python | def _handle_uninitialized_read(self, addr, inspect=True, events=True):
"""
The default uninitialized read handler. Returns symbolic bytes.
"""
if self._uninitialized_read_handler is None:
v = self.state.solver.Unconstrained("%s_%s" % (self.id, addr), self.width*self.state.arc... | [
"def",
"_handle_uninitialized_read",
"(",
"self",
",",
"addr",
",",
"inspect",
"=",
"True",
",",
"events",
"=",
"True",
")",
":",
"if",
"self",
".",
"_uninitialized_read_handler",
"is",
"None",
":",
"v",
"=",
"self",
".",
"state",
".",
"solver",
".",
"Un... | The default uninitialized read handler. Returns symbolic bytes. | [
"The",
"default",
"uninitialized",
"read",
"handler",
".",
"Returns",
"symbolic",
"bytes",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/fast_memory.py#L42-L50 | train |
angr/angr | angr/state_plugins/fast_memory.py | SimFastMemory._translate_addr | def _translate_addr(self, a): #pylint:disable=no-self-use
"""
Resolves this address.
"""
if isinstance(a, claripy.ast.Base) and not a.singlevalued:
raise SimFastMemoryError("address not supported")
return self.state.solver.eval(a) | python | def _translate_addr(self, a): #pylint:disable=no-self-use
"""
Resolves this address.
"""
if isinstance(a, claripy.ast.Base) and not a.singlevalued:
raise SimFastMemoryError("address not supported")
return self.state.solver.eval(a) | [
"def",
"_translate_addr",
"(",
"self",
",",
"a",
")",
":",
"#pylint:disable=no-self-use",
"if",
"isinstance",
"(",
"a",
",",
"claripy",
".",
"ast",
".",
"Base",
")",
"and",
"not",
"a",
".",
"singlevalued",
":",
"raise",
"SimFastMemoryError",
"(",
"\"address ... | Resolves this address. | [
"Resolves",
"this",
"address",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/fast_memory.py#L52-L58 | train |
angr/angr | angr/state_plugins/fast_memory.py | SimFastMemory._translate_size | def _translate_size(self, s): #pylint:disable=no-self-use
"""
Checks whether this size can be supported by FastMemory."
"""
if isinstance(s, claripy.ast.Base) and not s.singlevalued:
raise SimFastMemoryError("size not supported")
if s is None:
return s
... | python | def _translate_size(self, s): #pylint:disable=no-self-use
"""
Checks whether this size can be supported by FastMemory."
"""
if isinstance(s, claripy.ast.Base) and not s.singlevalued:
raise SimFastMemoryError("size not supported")
if s is None:
return s
... | [
"def",
"_translate_size",
"(",
"self",
",",
"s",
")",
":",
"#pylint:disable=no-self-use",
"if",
"isinstance",
"(",
"s",
",",
"claripy",
".",
"ast",
".",
"Base",
")",
"and",
"not",
"s",
".",
"singlevalued",
":",
"raise",
"SimFastMemoryError",
"(",
"\"size not... | Checks whether this size can be supported by FastMemory." | [
"Checks",
"whether",
"this",
"size",
"can",
"be",
"supported",
"by",
"FastMemory",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/fast_memory.py#L66-L74 | train |
angr/angr | angr/state_plugins/fast_memory.py | SimFastMemory._translate_cond | def _translate_cond(self, c): #pylint:disable=no-self-use
"""
Checks whether this condition can be supported by FastMemory."
"""
if isinstance(c, claripy.ast.Base) and not c.singlevalued:
raise SimFastMemoryError("size not supported")
if c is None:
return ... | python | def _translate_cond(self, c): #pylint:disable=no-self-use
"""
Checks whether this condition can be supported by FastMemory."
"""
if isinstance(c, claripy.ast.Base) and not c.singlevalued:
raise SimFastMemoryError("size not supported")
if c is None:
return ... | [
"def",
"_translate_cond",
"(",
"self",
",",
"c",
")",
":",
"#pylint:disable=no-self-use",
"if",
"isinstance",
"(",
"c",
",",
"claripy",
".",
"ast",
".",
"Base",
")",
"and",
"not",
"c",
".",
"singlevalued",
":",
"raise",
"SimFastMemoryError",
"(",
"\"size not... | Checks whether this condition can be supported by FastMemory." | [
"Checks",
"whether",
"this",
"condition",
"can",
"be",
"supported",
"by",
"FastMemory",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/fast_memory.py#L76-L85 | train |
angr/angr | angr/state_plugins/fast_memory.py | SimFastMemory._resolve_access | def _resolve_access(self, addr, size):
"""
Resolves a memory access of a certain size. Returns a sequence of the bases, offsets, and sizes of the accesses required
to fulfil this.
"""
# if we fit in one word
first_offset = addr % self.width
first_base = addr - fi... | python | def _resolve_access(self, addr, size):
"""
Resolves a memory access of a certain size. Returns a sequence of the bases, offsets, and sizes of the accesses required
to fulfil this.
"""
# if we fit in one word
first_offset = addr % self.width
first_base = addr - fi... | [
"def",
"_resolve_access",
"(",
"self",
",",
"addr",
",",
"size",
")",
":",
"# if we fit in one word",
"first_offset",
"=",
"addr",
"%",
"self",
".",
"width",
"first_base",
"=",
"addr",
"-",
"first_offset",
"if",
"first_offset",
"+",
"size",
"<=",
"self",
"."... | Resolves a memory access of a certain size. Returns a sequence of the bases, offsets, and sizes of the accesses required
to fulfil this. | [
"Resolves",
"a",
"memory",
"access",
"of",
"a",
"certain",
"size",
".",
"Returns",
"a",
"sequence",
"of",
"the",
"bases",
"offsets",
"and",
"sizes",
"of",
"the",
"accesses",
"required",
"to",
"fulfil",
"this",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/fast_memory.py#L87-L108 | train |
angr/angr | angr/state_plugins/fast_memory.py | SimFastMemory._single_load | def _single_load(self, addr, offset, size, inspect=True, events=True):
"""
Performs a single load.
"""
try:
d = self._contents[addr]
except KeyError:
d = self._handle_uninitialized_read(addr, inspect=inspect, events=events)
self._contents[addr]... | python | def _single_load(self, addr, offset, size, inspect=True, events=True):
"""
Performs a single load.
"""
try:
d = self._contents[addr]
except KeyError:
d = self._handle_uninitialized_read(addr, inspect=inspect, events=events)
self._contents[addr]... | [
"def",
"_single_load",
"(",
"self",
",",
"addr",
",",
"offset",
",",
"size",
",",
"inspect",
"=",
"True",
",",
"events",
"=",
"True",
")",
":",
"try",
":",
"d",
"=",
"self",
".",
"_contents",
"[",
"addr",
"]",
"except",
"KeyError",
":",
"d",
"=",
... | Performs a single load. | [
"Performs",
"a",
"single",
"load",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/fast_memory.py#L110-L123 | train |
angr/angr | angr/state_plugins/fast_memory.py | SimFastMemory._single_store | def _single_store(self, addr, offset, size, data):
"""
Performs a single store.
"""
if offset == 0 and size == self.width:
self._contents[addr] = data
elif offset == 0:
cur = self._single_load(addr, size, self.width - size)
self._contents[addr... | python | def _single_store(self, addr, offset, size, data):
"""
Performs a single store.
"""
if offset == 0 and size == self.width:
self._contents[addr] = data
elif offset == 0:
cur = self._single_load(addr, size, self.width - size)
self._contents[addr... | [
"def",
"_single_store",
"(",
"self",
",",
"addr",
",",
"offset",
",",
"size",
",",
"data",
")",
":",
"if",
"offset",
"==",
"0",
"and",
"size",
"==",
"self",
".",
"width",
":",
"self",
".",
"_contents",
"[",
"addr",
"]",
"=",
"data",
"elif",
"offset... | Performs a single store. | [
"Performs",
"a",
"single",
"store",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/fast_memory.py#L125-L142 | train |
angr/angr | angr/state_plugins/fast_memory.py | SimFastMemory.changed_bytes | def changed_bytes(self, other):
"""
Gets the set of changed bytes between self and other.
"""
changes = set()
l.warning("FastMemory.changed_bytes(): This implementation is very slow and only for debug purposes.")
for addr,v in self._contents.items():
for i i... | python | def changed_bytes(self, other):
"""
Gets the set of changed bytes between self and other.
"""
changes = set()
l.warning("FastMemory.changed_bytes(): This implementation is very slow and only for debug purposes.")
for addr,v in self._contents.items():
for i i... | [
"def",
"changed_bytes",
"(",
"self",
",",
"other",
")",
":",
"changes",
"=",
"set",
"(",
")",
"l",
".",
"warning",
"(",
"\"FastMemory.changed_bytes(): This implementation is very slow and only for debug purposes.\"",
")",
"for",
"addr",
",",
"v",
"in",
"self",
".",
... | Gets the set of changed bytes between self and other. | [
"Gets",
"the",
"set",
"of",
"changed",
"bytes",
"between",
"self",
"and",
"other",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/fast_memory.py#L213-L228 | train |
angr/angr | angr/analyses/binary_optimizer.py | BinaryOptimizer._redundant_stack_variable_removal | def _redundant_stack_variable_removal(self, function, data_graph):
"""
If an argument passed from the stack (i.e. dword ptr [ebp+4h]) is saved to a local variable on the stack at the
beginning of the function, and this local variable was never modified anywhere in this function, and no pointer
... | python | def _redundant_stack_variable_removal(self, function, data_graph):
"""
If an argument passed from the stack (i.e. dword ptr [ebp+4h]) is saved to a local variable on the stack at the
beginning of the function, and this local variable was never modified anywhere in this function, and no pointer
... | [
"def",
"_redundant_stack_variable_removal",
"(",
"self",
",",
"function",
",",
"data_graph",
")",
":",
"# check if there is any stack pointer being stored into any register other than esp",
"# basically check all consumers of stack pointers",
"stack_ptrs",
"=",
"[",
"]",
"sp_offset",... | If an argument passed from the stack (i.e. dword ptr [ebp+4h]) is saved to a local variable on the stack at the
beginning of the function, and this local variable was never modified anywhere in this function, and no pointer
of any stack variable is saved in any register, then we can replace all referenc... | [
"If",
"an",
"argument",
"passed",
"from",
"the",
"stack",
"(",
"i",
".",
"e",
".",
"dword",
"ptr",
"[",
"ebp",
"+",
"4h",
"]",
")",
"is",
"saved",
"to",
"a",
"local",
"variable",
"on",
"the",
"stack",
"at",
"the",
"beginning",
"of",
"the",
"functio... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/binary_optimizer.py#L242-L352 | train |
angr/angr | angr/analyses/binary_optimizer.py | BinaryOptimizer._register_reallocation | def _register_reallocation(self, function, data_graph):
"""
Find unused registers throughout the function, and use those registers to replace stack variables.
Only functions that satisfy the following criteria can be optimized in this way:
- The function does not call any other function... | python | def _register_reallocation(self, function, data_graph):
"""
Find unused registers throughout the function, and use those registers to replace stack variables.
Only functions that satisfy the following criteria can be optimized in this way:
- The function does not call any other function... | [
"def",
"_register_reallocation",
"(",
"self",
",",
"function",
",",
"data_graph",
")",
":",
"# make sure this function does not call other functions",
"if",
"function",
".",
"callout_sites",
":",
"return",
"if",
"len",
"(",
"function",
".",
"endpoints",
")",
"!=",
"... | Find unused registers throughout the function, and use those registers to replace stack variables.
Only functions that satisfy the following criteria can be optimized in this way:
- The function does not call any other function.
- The function does not use esp to index any stack variable.
... | [
"Find",
"unused",
"registers",
"throughout",
"the",
"function",
"and",
"use",
"those",
"registers",
"to",
"replace",
"stack",
"variables",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/binary_optimizer.py#L354-L614 | train |
angr/angr | angr/analyses/binary_optimizer.py | BinaryOptimizer._dead_assignment_elimination | def _dead_assignment_elimination(self, function, data_graph): #pylint:disable=unused-argument
"""
Remove assignments to registers that has no consumers, but immediately killed.
BROKEN - DO NOT USE IT
:param angr.knowledge.Function function:
:param networkx.MultiDiGraph data_gr... | python | def _dead_assignment_elimination(self, function, data_graph): #pylint:disable=unused-argument
"""
Remove assignments to registers that has no consumers, but immediately killed.
BROKEN - DO NOT USE IT
:param angr.knowledge.Function function:
:param networkx.MultiDiGraph data_gr... | [
"def",
"_dead_assignment_elimination",
"(",
"self",
",",
"function",
",",
"data_graph",
")",
":",
"#pylint:disable=unused-argument",
"register_pvs",
"=",
"set",
"(",
")",
"for",
"node",
"in",
"data_graph",
".",
"nodes",
"(",
")",
":",
"if",
"isinstance",
"(",
... | Remove assignments to registers that has no consumers, but immediately killed.
BROKEN - DO NOT USE IT
:param angr.knowledge.Function function:
:param networkx.MultiDiGraph data_graph:
:return: None | [
"Remove",
"assignments",
"to",
"registers",
"that",
"has",
"no",
"consumers",
"but",
"immediately",
"killed",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/binary_optimizer.py#L616-L648 | train |
angr/angr | angr/simos/windows.py | SimWindows.initialize_segment_register_x64 | def initialize_segment_register_x64(self, state, concrete_target):
"""
Set the gs register in the angr to the value of the fs register in the concrete process
:param state: state which will be modified
:param concrete_target: concrete target that will be used to read t... | python | def initialize_segment_register_x64(self, state, concrete_target):
"""
Set the gs register in the angr to the value of the fs register in the concrete process
:param state: state which will be modified
:param concrete_target: concrete target that will be used to read t... | [
"def",
"initialize_segment_register_x64",
"(",
"self",
",",
"state",
",",
"concrete_target",
")",
":",
"_l",
".",
"debug",
"(",
"\"Synchronizing gs segment register\"",
")",
"state",
".",
"regs",
".",
"gs",
"=",
"self",
".",
"_read_gs_register_x64",
"(",
"concrete... | Set the gs register in the angr to the value of the fs register in the concrete process
:param state: state which will be modified
:param concrete_target: concrete target that will be used to read the fs register
:return: None | [
"Set",
"the",
"gs",
"register",
"in",
"the",
"angr",
"to",
"the",
"value",
"of",
"the",
"fs",
"register",
"in",
"the",
"concrete",
"process"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/simos/windows.py#L465-L474 | train |
angr/angr | angr/simos/windows.py | SimWindows.initialize_gdt_x86 | def initialize_gdt_x86(self, state, concrete_target):
"""
Create a GDT in the state memory and populate the segment registers.
:param state: state which will be modified
:param concrete_target: concrete target that will be used to read the fs register
:return: ... | python | def initialize_gdt_x86(self, state, concrete_target):
"""
Create a GDT in the state memory and populate the segment registers.
:param state: state which will be modified
:param concrete_target: concrete target that will be used to read the fs register
:return: ... | [
"def",
"initialize_gdt_x86",
"(",
"self",
",",
"state",
",",
"concrete_target",
")",
":",
"_l",
".",
"debug",
"(",
"\"Creating Global Descriptor Table and synchronizing fs segment register\"",
")",
"fs",
"=",
"self",
".",
"_read_fs_register_x86",
"(",
"concrete_target",
... | Create a GDT in the state memory and populate the segment registers.
:param state: state which will be modified
:param concrete_target: concrete target that will be used to read the fs register
:return: the created GlobalDescriptorTable object | [
"Create",
"a",
"GDT",
"in",
"the",
"state",
"memory",
"and",
"populate",
"the",
"segment",
"registers",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/simos/windows.py#L476-L488 | train |
angr/angr | angr/state_plugins/jni_references.py | SimStateJNIReferences.lookup | def lookup(self, opaque_ref):
"""
Lookups the object that was used for creating the reference.
"""
opaque_ref_value = self._get_reference_value(opaque_ref)
# check local refs
if opaque_ref_value in self.local_refs:
return self.local_refs[opaque_ref_value]
... | python | def lookup(self, opaque_ref):
"""
Lookups the object that was used for creating the reference.
"""
opaque_ref_value = self._get_reference_value(opaque_ref)
# check local refs
if opaque_ref_value in self.local_refs:
return self.local_refs[opaque_ref_value]
... | [
"def",
"lookup",
"(",
"self",
",",
"opaque_ref",
")",
":",
"opaque_ref_value",
"=",
"self",
".",
"_get_reference_value",
"(",
"opaque_ref",
")",
"# check local refs",
"if",
"opaque_ref_value",
"in",
"self",
".",
"local_refs",
":",
"return",
"self",
".",
"local_r... | Lookups the object that was used for creating the reference. | [
"Lookups",
"the",
"object",
"that",
"was",
"used",
"for",
"creating",
"the",
"reference",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/jni_references.py#L21-L33 | train |
angr/angr | angr/state_plugins/jni_references.py | SimStateJNIReferences.create_new_reference | def create_new_reference(self, obj, global_ref=False):
"""
Create a new reference thats maps to the given object.
:param obj: Object which gets referenced.
:param bool global_ref: Whether a local or global reference is created.
"""
# get an unique address
... | python | def create_new_reference(self, obj, global_ref=False):
"""
Create a new reference thats maps to the given object.
:param obj: Object which gets referenced.
:param bool global_ref: Whether a local or global reference is created.
"""
# get an unique address
... | [
"def",
"create_new_reference",
"(",
"self",
",",
"obj",
",",
"global_ref",
"=",
"False",
")",
":",
"# get an unique address",
"opaque_ref",
"=",
"self",
".",
"state",
".",
"project",
".",
"loader",
".",
"extern_object",
".",
"allocate",
"(",
")",
"# map the ob... | Create a new reference thats maps to the given object.
:param obj: Object which gets referenced.
:param bool global_ref: Whether a local or global reference is created. | [
"Create",
"a",
"new",
"reference",
"thats",
"maps",
"to",
"the",
"given",
"object",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/jni_references.py#L35-L50 | train |
angr/angr | angr/state_plugins/jni_references.py | SimStateJNIReferences.delete_reference | def delete_reference(self, opaque_ref, global_ref=False):
"""
Delete the stored mapping of a reference.
:param opaque_ref: Reference which should be removed.
:param bool global_ref: Whether opaque_ref is a local or global
reference.
"""
... | python | def delete_reference(self, opaque_ref, global_ref=False):
"""
Delete the stored mapping of a reference.
:param opaque_ref: Reference which should be removed.
:param bool global_ref: Whether opaque_ref is a local or global
reference.
"""
... | [
"def",
"delete_reference",
"(",
"self",
",",
"opaque_ref",
",",
"global_ref",
"=",
"False",
")",
":",
"opaque_ref_value",
"=",
"self",
".",
"_get_reference_value",
"(",
"opaque_ref",
")",
"if",
"global_ref",
":",
"del",
"self",
".",
"global_refs",
"[",
"opaque... | Delete the stored mapping of a reference.
:param opaque_ref: Reference which should be removed.
:param bool global_ref: Whether opaque_ref is a local or global
reference. | [
"Delete",
"the",
"stored",
"mapping",
"of",
"a",
"reference",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/jni_references.py#L58-L70 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | PendingJobs.pop_job | def pop_job(self, returning=True):
"""
Pop a job from the pending jobs list.
When returning == True, we prioritize the jobs whose functions are known to be returning (function.returning is
True). As an optimization, we are sorting the pending jobs list according to job.function.returnin... | python | def pop_job(self, returning=True):
"""
Pop a job from the pending jobs list.
When returning == True, we prioritize the jobs whose functions are known to be returning (function.returning is
True). As an optimization, we are sorting the pending jobs list according to job.function.returnin... | [
"def",
"pop_job",
"(",
"self",
",",
"returning",
"=",
"True",
")",
":",
"if",
"not",
"self",
":",
"return",
"None",
"if",
"not",
"returning",
":",
"return",
"self",
".",
"_pop_job",
"(",
"next",
"(",
"reversed",
"(",
"self",
".",
"_jobs",
".",
"keys"... | Pop a job from the pending jobs list.
When returning == True, we prioritize the jobs whose functions are known to be returning (function.returning is
True). As an optimization, we are sorting the pending jobs list according to job.function.returning.
:param bool returning: Only pop a pending j... | [
"Pop",
"a",
"job",
"from",
"the",
"pending",
"jobs",
"list",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L102-L126 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | PendingJobs.cleanup | def cleanup(self):
"""
Remove those pending exits if:
a) they are the return exits of non-returning SimProcedures
b) they are the return exits of non-returning syscalls
b) they are the return exits of non-returning functions
:return: None
"""
pending_exi... | python | def cleanup(self):
"""
Remove those pending exits if:
a) they are the return exits of non-returning SimProcedures
b) they are the return exits of non-returning syscalls
b) they are the return exits of non-returning functions
:return: None
"""
pending_exi... | [
"def",
"cleanup",
"(",
"self",
")",
":",
"pending_exits_to_remove",
"=",
"defaultdict",
"(",
"list",
")",
"for",
"func_addr",
"in",
"self",
".",
"_updated_functions",
":",
"if",
"func_addr",
"not",
"in",
"self",
".",
"_jobs",
":",
"continue",
"jobs",
"=",
... | Remove those pending exits if:
a) they are the return exits of non-returning SimProcedures
b) they are the return exits of non-returning syscalls
b) they are the return exits of non-returning functions
:return: None | [
"Remove",
"those",
"pending",
"exits",
"if",
":",
"a",
")",
"they",
"are",
"the",
"return",
"exits",
"of",
"non",
"-",
"returning",
"SimProcedures",
"b",
")",
"they",
"are",
"the",
"return",
"exits",
"of",
"non",
"-",
"returning",
"syscalls",
"b",
")",
... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L128-L171 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | PendingJobs.add_returning_function | def add_returning_function(self, func_addr):
"""
Mark a function as returning.
:param int func_addr: Address of the function that returns.
:return: None
"""
self._returning_functions.add(func_addr)
self._updated_functions.add(func_addr) | python | def add_returning_function(self, func_addr):
"""
Mark a function as returning.
:param int func_addr: Address of the function that returns.
:return: None
"""
self._returning_functions.add(func_addr)
self._updated_functions.add(func_addr) | [
"def",
"add_returning_function",
"(",
"self",
",",
"func_addr",
")",
":",
"self",
".",
"_returning_functions",
".",
"add",
"(",
"func_addr",
")",
"self",
".",
"_updated_functions",
".",
"add",
"(",
"func_addr",
")"
] | Mark a function as returning.
:param int func_addr: Address of the function that returns.
:return: None | [
"Mark",
"a",
"function",
"as",
"returning",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L173-L182 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._calc_entropy | def _calc_entropy(data, size=None):
"""
Calculate the entropy of a piece of data
:param data: The target data to calculate entropy on
:param size: Size of the data, Optional.
:return: A float
"""
if not data:
return 0
entropy = 0
if s... | python | def _calc_entropy(data, size=None):
"""
Calculate the entropy of a piece of data
:param data: The target data to calculate entropy on
:param size: Size of the data, Optional.
:return: A float
"""
if not data:
return 0
entropy = 0
if s... | [
"def",
"_calc_entropy",
"(",
"data",
",",
"size",
"=",
"None",
")",
":",
"if",
"not",
"data",
":",
"return",
"0",
"entropy",
"=",
"0",
"if",
"size",
"is",
"None",
":",
"size",
"=",
"len",
"(",
"data",
")",
"data",
"=",
"bytes",
"(",
"pyvex",
".",... | Calculate the entropy of a piece of data
:param data: The target data to calculate entropy on
:param size: Size of the data, Optional.
:return: A float | [
"Calculate",
"the",
"entropy",
"of",
"a",
"piece",
"of",
"data"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L641-L661 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._inside_regions | def _inside_regions(self, address):
"""
Check if the address is inside any existing region.
:param int address: Address to check.
:return: True if the address is within one of the memory regions, False otherwise.
:rtype: bool
"""
try:
... | python | def _inside_regions(self, address):
"""
Check if the address is inside any existing region.
:param int address: Address to check.
:return: True if the address is within one of the memory regions, False otherwise.
:rtype: bool
"""
try:
... | [
"def",
"_inside_regions",
"(",
"self",
",",
"address",
")",
":",
"try",
":",
"start_addr",
"=",
"next",
"(",
"self",
".",
"_regions",
".",
"irange",
"(",
"maximum",
"=",
"address",
",",
"reverse",
"=",
"True",
")",
")",
"except",
"StopIteration",
":",
... | Check if the address is inside any existing region.
:param int address: Address to check.
:return: True if the address is within one of the memory regions, False otherwise.
:rtype: bool | [
"Check",
"if",
"the",
"address",
"is",
"inside",
"any",
"existing",
"region",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L698-L712 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._get_min_addr | def _get_min_addr(self):
"""
Get the minimum address out of all regions. We assume self._regions is sorted.
:return: The minimum address.
:rtype: int
"""
if not self._regions:
if self.project.arch.name != "Soot":
l.error("self._regions is em... | python | def _get_min_addr(self):
"""
Get the minimum address out of all regions. We assume self._regions is sorted.
:return: The minimum address.
:rtype: int
"""
if not self._regions:
if self.project.arch.name != "Soot":
l.error("self._regions is em... | [
"def",
"_get_min_addr",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"_regions",
":",
"if",
"self",
".",
"project",
".",
"arch",
".",
"name",
"!=",
"\"Soot\"",
":",
"l",
".",
"error",
"(",
"\"self._regions is empty or not properly set.\"",
")",
"return",... | Get the minimum address out of all regions. We assume self._regions is sorted.
:return: The minimum address.
:rtype: int | [
"Get",
"the",
"minimum",
"address",
"out",
"of",
"all",
"regions",
".",
"We",
"assume",
"self",
".",
"_regions",
"is",
"sorted",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L714-L727 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._next_address_in_regions | def _next_address_in_regions(self, address):
"""
Return the next immediate address that is inside any of the regions.
:param int address: The address to start scanning.
:return: The next address that is inside one of the memory regions.
:rtype: int
... | python | def _next_address_in_regions(self, address):
"""
Return the next immediate address that is inside any of the regions.
:param int address: The address to start scanning.
:return: The next address that is inside one of the memory regions.
:rtype: int
... | [
"def",
"_next_address_in_regions",
"(",
"self",
",",
"address",
")",
":",
"if",
"self",
".",
"_inside_regions",
"(",
"address",
")",
":",
"return",
"address",
"try",
":",
"return",
"next",
"(",
"self",
".",
"_regions",
".",
"irange",
"(",
"minimum",
"=",
... | Return the next immediate address that is inside any of the regions.
:param int address: The address to start scanning.
:return: The next address that is inside one of the memory regions.
:rtype: int | [
"Return",
"the",
"next",
"immediate",
"address",
"that",
"is",
"inside",
"any",
"of",
"the",
"regions",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L729-L744 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._next_unscanned_addr | def _next_unscanned_addr(self, alignment=None):
"""
Find the next address that we haven't processed
:param alignment: Assures the address returns must be aligned by this number
:return: An address to process next, or None if all addresses have been processed
"""
# TODO:... | python | def _next_unscanned_addr(self, alignment=None):
"""
Find the next address that we haven't processed
:param alignment: Assures the address returns must be aligned by this number
:return: An address to process next, or None if all addresses have been processed
"""
# TODO:... | [
"def",
"_next_unscanned_addr",
"(",
"self",
",",
"alignment",
"=",
"None",
")",
":",
"# TODO: Take care of those functions that are already generated",
"if",
"self",
".",
"_next_addr",
"is",
"None",
":",
"self",
".",
"_next_addr",
"=",
"self",
".",
"_get_min_addr",
... | Find the next address that we haven't processed
:param alignment: Assures the address returns must be aligned by this number
:return: An address to process next, or None if all addresses have been processed | [
"Find",
"the",
"next",
"address",
"that",
"we",
"haven",
"t",
"processed"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L748-L800 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._next_code_addr_core | def _next_code_addr_core(self):
"""
Call _next_unscanned_addr() first to get the next address that is not scanned. Then check if data locates at
that address seems to be code or not. If not, we'll continue to for the next un-scanned address.
"""
next_addr = self._next_unscanned_... | python | def _next_code_addr_core(self):
"""
Call _next_unscanned_addr() first to get the next address that is not scanned. Then check if data locates at
that address seems to be code or not. If not, we'll continue to for the next un-scanned address.
"""
next_addr = self._next_unscanned_... | [
"def",
"_next_code_addr_core",
"(",
"self",
")",
":",
"next_addr",
"=",
"self",
".",
"_next_unscanned_addr",
"(",
")",
"if",
"next_addr",
"is",
"None",
":",
"return",
"None",
"start_addr",
"=",
"next_addr",
"while",
"True",
":",
"string_length",
"=",
"self",
... | Call _next_unscanned_addr() first to get the next address that is not scanned. Then check if data locates at
that address seems to be code or not. If not, we'll continue to for the next un-scanned address. | [
"Call",
"_next_unscanned_addr",
"()",
"first",
"to",
"get",
"the",
"next",
"address",
"that",
"is",
"not",
"scanned",
".",
"Then",
"check",
"if",
"data",
"locates",
"at",
"that",
"address",
"seems",
"to",
"be",
"code",
"or",
"not",
".",
"If",
"not",
"we"... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L866-L908 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._pre_job_handling | def _pre_job_handling(self, job): # pylint:disable=arguments-differ
"""
Some pre job-processing tasks, like update progress bar.
:param CFGJob job: The CFGJob instance.
:return: None
"""
if self._low_priority:
self._release_gil(len(self._nodes), 20, 0.0001)... | python | def _pre_job_handling(self, job): # pylint:disable=arguments-differ
"""
Some pre job-processing tasks, like update progress bar.
:param CFGJob job: The CFGJob instance.
:return: None
"""
if self._low_priority:
self._release_gil(len(self._nodes), 20, 0.0001)... | [
"def",
"_pre_job_handling",
"(",
"self",
",",
"job",
")",
":",
"# pylint:disable=arguments-differ",
"if",
"self",
".",
"_low_priority",
":",
"self",
".",
"_release_gil",
"(",
"len",
"(",
"self",
".",
"_nodes",
")",
",",
"20",
",",
"0.0001",
")",
"# a new ent... | Some pre job-processing tasks, like update progress bar.
:param CFGJob job: The CFGJob instance.
:return: None | [
"Some",
"pre",
"job",
"-",
"processing",
"tasks",
"like",
"update",
"progress",
"bar",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L989-L1018 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._func_addrs_from_symbols | def _func_addrs_from_symbols(self):
"""
Get all possible function addresses that are specified by the symbols in the binary
:return: A set of addresses that are probably functions
:rtype: set
"""
return {sym.rebased_addr for sym in self._binary.symbols if sym.is_functio... | python | def _func_addrs_from_symbols(self):
"""
Get all possible function addresses that are specified by the symbols in the binary
:return: A set of addresses that are probably functions
:rtype: set
"""
return {sym.rebased_addr for sym in self._binary.symbols if sym.is_functio... | [
"def",
"_func_addrs_from_symbols",
"(",
"self",
")",
":",
"return",
"{",
"sym",
".",
"rebased_addr",
"for",
"sym",
"in",
"self",
".",
"_binary",
".",
"symbols",
"if",
"sym",
".",
"is_function",
"}"
] | Get all possible function addresses that are specified by the symbols in the binary
:return: A set of addresses that are probably functions
:rtype: set | [
"Get",
"all",
"possible",
"function",
"addresses",
"that",
"are",
"specified",
"by",
"the",
"symbols",
"in",
"the",
"binary"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L1225-L1233 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._func_addrs_from_prologues | def _func_addrs_from_prologues(self):
"""
Scan the entire program image for function prologues, and start code scanning at those positions
:return: A list of possible function addresses
"""
# Pre-compile all regexes
regexes = list()
for ins_regex in self.project... | python | def _func_addrs_from_prologues(self):
"""
Scan the entire program image for function prologues, and start code scanning at those positions
:return: A list of possible function addresses
"""
# Pre-compile all regexes
regexes = list()
for ins_regex in self.project... | [
"def",
"_func_addrs_from_prologues",
"(",
"self",
")",
":",
"# Pre-compile all regexes",
"regexes",
"=",
"list",
"(",
")",
"for",
"ins_regex",
"in",
"self",
".",
"project",
".",
"arch",
".",
"function_prologs",
":",
"r",
"=",
"re",
".",
"compile",
"(",
"ins_... | Scan the entire program image for function prologues, and start code scanning at those positions
:return: A list of possible function addresses | [
"Scan",
"the",
"entire",
"program",
"image",
"for",
"function",
"prologues",
"and",
"start",
"code",
"scanning",
"at",
"those",
"positions"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L1235-L1282 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._scan_block | def _scan_block(self, cfg_job):
"""
Scan a basic block starting at a specific address
:param CFGJob cfg_job: The CFGJob instance.
:return: a list of successors
:rtype: list
"""
addr = cfg_job.addr
current_func_addr = cfg_job.func_addr
# Fix the ... | python | def _scan_block(self, cfg_job):
"""
Scan a basic block starting at a specific address
:param CFGJob cfg_job: The CFGJob instance.
:return: a list of successors
:rtype: list
"""
addr = cfg_job.addr
current_func_addr = cfg_job.func_addr
# Fix the ... | [
"def",
"_scan_block",
"(",
"self",
",",
"cfg_job",
")",
":",
"addr",
"=",
"cfg_job",
".",
"addr",
"current_func_addr",
"=",
"cfg_job",
".",
"func_addr",
"# Fix the function address",
"# This is for rare cases where we cannot successfully determine the end boundary of a previous... | Scan a basic block starting at a specific address
:param CFGJob cfg_job: The CFGJob instance.
:return: a list of successors
:rtype: list | [
"Scan",
"a",
"basic",
"block",
"starting",
"at",
"a",
"specific",
"address"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L1286-L1311 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._scan_procedure | def _scan_procedure(self, cfg_job, current_func_addr):
"""
Checks the hooking procedure for this address searching for new static
exit points to add to successors (generating entries for them)
if this address has not been traced before. Updates previous CFG nodes
with edges.
... | python | def _scan_procedure(self, cfg_job, current_func_addr):
"""
Checks the hooking procedure for this address searching for new static
exit points to add to successors (generating entries for them)
if this address has not been traced before. Updates previous CFG nodes
with edges.
... | [
"def",
"_scan_procedure",
"(",
"self",
",",
"cfg_job",
",",
"current_func_addr",
")",
":",
"addr",
"=",
"cfg_job",
".",
"addr",
"try",
":",
"if",
"self",
".",
"project",
".",
"is_hooked",
"(",
"addr",
")",
":",
"procedure",
"=",
"self",
".",
"project",
... | Checks the hooking procedure for this address searching for new static
exit points to add to successors (generating entries for them)
if this address has not been traced before. Updates previous CFG nodes
with edges.
:param CFGJob cfg_job: The CFGJob instance.
:param int cu... | [
"Checks",
"the",
"hooking",
"procedure",
"for",
"this",
"address",
"searching",
"for",
"new",
"static",
"exit",
"points",
"to",
"add",
"to",
"successors",
"(",
"generating",
"entries",
"for",
"them",
")",
"if",
"this",
"address",
"has",
"not",
"been",
"trace... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L1313-L1402 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._scan_irsb | def _scan_irsb(self, cfg_job, current_func_addr):
"""
Generate a list of successors (generating them each as entries) to IRSB.
Updates previous CFG nodes with edges.
:param CFGJob cfg_job: The CFGJob instance.
:param int current_func_addr: Address of the current function
... | python | def _scan_irsb(self, cfg_job, current_func_addr):
"""
Generate a list of successors (generating them each as entries) to IRSB.
Updates previous CFG nodes with edges.
:param CFGJob cfg_job: The CFGJob instance.
:param int current_func_addr: Address of the current function
... | [
"def",
"_scan_irsb",
"(",
"self",
",",
"cfg_job",
",",
"current_func_addr",
")",
":",
"addr",
",",
"function_addr",
",",
"cfg_node",
",",
"irsb",
"=",
"self",
".",
"_generate_cfgnode",
"(",
"cfg_job",
",",
"current_func_addr",
")",
"# Add edges going to this node ... | Generate a list of successors (generating them each as entries) to IRSB.
Updates previous CFG nodes with edges.
:param CFGJob cfg_job: The CFGJob instance.
:param int current_func_addr: Address of the current function
:return: a list of successors
:rtype: list | [
"Generate",
"a",
"list",
"of",
"successors",
"(",
"generating",
"them",
"each",
"as",
"entries",
")",
"to",
"IRSB",
".",
"Updates",
"previous",
"CFG",
"nodes",
"with",
"edges",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L1404-L1498 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._create_jobs | def _create_jobs(self, target, jumpkind, current_function_addr, irsb, addr, cfg_node, ins_addr, stmt_idx):
"""
Given a node and details of a successor, makes a list of CFGJobs
and if it is a call or exit marks it appropriately so in the CFG
:param int target: Destination of the... | python | def _create_jobs(self, target, jumpkind, current_function_addr, irsb, addr, cfg_node, ins_addr, stmt_idx):
"""
Given a node and details of a successor, makes a list of CFGJobs
and if it is a call or exit marks it appropriately so in the CFG
:param int target: Destination of the... | [
"def",
"_create_jobs",
"(",
"self",
",",
"target",
",",
"jumpkind",
",",
"current_function_addr",
",",
"irsb",
",",
"addr",
",",
"cfg_node",
",",
"ins_addr",
",",
"stmt_idx",
")",
":",
"if",
"type",
"(",
"target",
")",
"is",
"pyvex",
".",
"IRExpr",
".",
... | Given a node and details of a successor, makes a list of CFGJobs
and if it is a call or exit marks it appropriately so in the CFG
:param int target: Destination of the resultant job
:param str jumpkind: The jumpkind of the edge going to this node
:param int current_funct... | [
"Given",
"a",
"node",
"and",
"details",
"of",
"a",
"successor",
"makes",
"a",
"list",
"of",
"CFGJobs",
"and",
"if",
"it",
"is",
"a",
"call",
"or",
"exit",
"marks",
"it",
"appropriately",
"so",
"in",
"the",
"CFG"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L1500-L1671 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._create_job_call | def _create_job_call(self, addr, irsb, cfg_node, stmt_idx, ins_addr, current_function_addr, target_addr, jumpkind,
is_syscall=False):
"""
Generate a CFGJob for target address, also adding to _pending_entries
if returning to succeeding position (if irsb arg is populated)
... | python | def _create_job_call(self, addr, irsb, cfg_node, stmt_idx, ins_addr, current_function_addr, target_addr, jumpkind,
is_syscall=False):
"""
Generate a CFGJob for target address, also adding to _pending_entries
if returning to succeeding position (if irsb arg is populated)
... | [
"def",
"_create_job_call",
"(",
"self",
",",
"addr",
",",
"irsb",
",",
"cfg_node",
",",
"stmt_idx",
",",
"ins_addr",
",",
"current_function_addr",
",",
"target_addr",
",",
"jumpkind",
",",
"is_syscall",
"=",
"False",
")",
":",
"jobs",
"=",
"[",
"]",
"if",
... | Generate a CFGJob for target address, also adding to _pending_entries
if returning to succeeding position (if irsb arg is populated)
:param int addr: Address of the predecessor node
:param pyvex.IRSB irsb: IRSB of the predecessor node
:param CFGNode cfg_node: The CFGNo... | [
"Generate",
"a",
"CFGJob",
"for",
"target",
"address",
"also",
"adding",
"to",
"_pending_entries",
"if",
"returning",
"to",
"succeeding",
"position",
"(",
"if",
"irsb",
"arg",
"is",
"populated",
")"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L1673-L1797 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._collect_data_references | def _collect_data_references(self, irsb, irsb_addr):
"""
Unoptimises IRSB and _add_data_reference's for individual statements or
for parts of statements (e.g. Store)
:param pyvex.IRSB irsb: Block to scan for data references
:param int irsb_addr: Address of block
:return:... | python | def _collect_data_references(self, irsb, irsb_addr):
"""
Unoptimises IRSB and _add_data_reference's for individual statements or
for parts of statements (e.g. Store)
:param pyvex.IRSB irsb: Block to scan for data references
:param int irsb_addr: Address of block
:return:... | [
"def",
"_collect_data_references",
"(",
"self",
",",
"irsb",
",",
"irsb_addr",
")",
":",
"if",
"irsb",
".",
"data_refs",
":",
"self",
".",
"_process_irsb_data_refs",
"(",
"irsb",
")",
"elif",
"irsb",
".",
"statements",
":",
"irsb",
"=",
"self",
".",
"_unop... | Unoptimises IRSB and _add_data_reference's for individual statements or
for parts of statements (e.g. Store)
:param pyvex.IRSB irsb: Block to scan for data references
:param int irsb_addr: Address of block
:return: None | [
"Unoptimises",
"IRSB",
"and",
"_add_data_reference",
"s",
"for",
"individual",
"statements",
"or",
"for",
"parts",
"of",
"statements",
"(",
"e",
".",
"g",
".",
"Store",
")"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L1801-L1816 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._add_data_reference | def _add_data_reference(self, irsb_addr, stmt_idx, insn_addr, data_addr, # pylint: disable=unused-argument
data_size=None, data_type=None):
"""
Checks addresses are in the correct segments and creates or updates
MemoryData in _memory_data as appropriate, labelling as... | python | def _add_data_reference(self, irsb_addr, stmt_idx, insn_addr, data_addr, # pylint: disable=unused-argument
data_size=None, data_type=None):
"""
Checks addresses are in the correct segments and creates or updates
MemoryData in _memory_data as appropriate, labelling as... | [
"def",
"_add_data_reference",
"(",
"self",
",",
"irsb_addr",
",",
"stmt_idx",
",",
"insn_addr",
",",
"data_addr",
",",
"# pylint: disable=unused-argument",
"data_size",
"=",
"None",
",",
"data_type",
"=",
"None",
")",
":",
"# Make sure data_addr is within a valid memory... | Checks addresses are in the correct segments and creates or updates
MemoryData in _memory_data as appropriate, labelling as segment
boundaries or data type
:param int irsb_addr: irsb address
:param int stmt_idx: Statement ID
:param int insn_addr: instruction address
:par... | [
"Checks",
"addresses",
"are",
"in",
"the",
"correct",
"segments",
"and",
"creates",
"or",
"updates",
"MemoryData",
"in",
"_memory_data",
"as",
"appropriate",
"labelling",
"as",
"segment",
"boundaries",
"or",
"data",
"type"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L1942-L1991 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._guess_data_type | def _guess_data_type(self, data_addr, max_size, content_holder=None):
"""
Make a guess to the data type.
Users can provide their own data type guessing code when initializing CFGFast instance, and each guessing
handler will be called if this method fails to determine what the data is.
... | python | def _guess_data_type(self, data_addr, max_size, content_holder=None):
"""
Make a guess to the data type.
Users can provide their own data type guessing code when initializing CFGFast instance, and each guessing
handler will be called if this method fails to determine what the data is.
... | [
"def",
"_guess_data_type",
"(",
"self",
",",
"data_addr",
",",
"max_size",
",",
"content_holder",
"=",
"None",
")",
":",
"try",
":",
"ref",
"=",
"next",
"(",
"iter",
"(",
"self",
".",
"model",
".",
"references",
".",
"data_addr_to_ref",
"[",
"data_addr",
... | Make a guess to the data type.
Users can provide their own data type guessing code when initializing CFGFast instance, and each guessing
handler will be called if this method fails to determine what the data is.
:param int data_addr: Address of the data.
:param int max_size: The maximu... | [
"Make",
"a",
"guess",
"to",
"the",
"data",
"type",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2140-L2259 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._resolve_plt | def _resolve_plt(self, addr, irsb, indir_jump):
"""
Determine if the IRSB at the given address is a PLT stub. If it is, concretely execute the basic block to
resolve the jump target.
:param int addr: Address of the block.
:param irsb: The basic ... | python | def _resolve_plt(self, addr, irsb, indir_jump):
"""
Determine if the IRSB at the given address is a PLT stub. If it is, concretely execute the basic block to
resolve the jump target.
:param int addr: Address of the block.
:param irsb: The basic ... | [
"def",
"_resolve_plt",
"(",
"self",
",",
"addr",
",",
"irsb",
",",
"indir_jump",
")",
":",
"# is the address identified by CLE as a PLT stub?",
"if",
"self",
".",
"project",
".",
"loader",
".",
"all_elf_objects",
":",
"# restrict this heuristics to ELF files only",
"if"... | Determine if the IRSB at the given address is a PLT stub. If it is, concretely execute the basic block to
resolve the jump target.
:param int addr: Address of the block.
:param irsb: The basic block.
:param IndirectJump indir_jump: The IndirectJump inst... | [
"Determine",
"if",
"the",
"IRSB",
"at",
"the",
"given",
"address",
"is",
"a",
"PLT",
"stub",
".",
"If",
"it",
"is",
"concretely",
"execute",
"the",
"basic",
"block",
"to",
"resolve",
"the",
"jump",
"target",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2263-L2301 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._indirect_jump_resolved | def _indirect_jump_resolved(self, jump, jump_addr, resolved_by, targets):
"""
Called when an indirect jump is successfully resolved.
:param IndirectJump jump: The resolved indirect jump.
:param IndirectJumpResolver resolved_by: The resolver used to resolve this indi... | python | def _indirect_jump_resolved(self, jump, jump_addr, resolved_by, targets):
"""
Called when an indirect jump is successfully resolved.
:param IndirectJump jump: The resolved indirect jump.
:param IndirectJumpResolver resolved_by: The resolver used to resolve this indi... | [
"def",
"_indirect_jump_resolved",
"(",
"self",
",",
"jump",
",",
"jump_addr",
",",
"resolved_by",
",",
"targets",
")",
":",
"from",
".",
"indirect_jump_resolvers",
".",
"jumptable",
"import",
"JumpTableResolver",
"source_addr",
"=",
"jump",
".",
"addr",
"if",
"i... | Called when an indirect jump is successfully resolved.
:param IndirectJump jump: The resolved indirect jump.
:param IndirectJumpResolver resolved_by: The resolver used to resolve this indirect jump.
:param list targets: List of indirect jump targets.
... | [
"Called",
"when",
"an",
"indirect",
"jump",
"is",
"successfully",
"resolved",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2303-L2344 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._indirect_jump_unresolved | def _indirect_jump_unresolved(self, jump):
"""
Called when we cannot resolve an indirect jump.
:param IndirectJump jump: The unresolved indirect jump.
:return: None
"""
# add a node from this node to UnresolvableJumpTarget or UnresolvalbeCallTarget node,
# d... | python | def _indirect_jump_unresolved(self, jump):
"""
Called when we cannot resolve an indirect jump.
:param IndirectJump jump: The unresolved indirect jump.
:return: None
"""
# add a node from this node to UnresolvableJumpTarget or UnresolvalbeCallTarget node,
# d... | [
"def",
"_indirect_jump_unresolved",
"(",
"self",
",",
"jump",
")",
":",
"# add a node from this node to UnresolvableJumpTarget or UnresolvalbeCallTarget node,",
"# depending on its jump kind",
"src_node",
"=",
"self",
".",
"_nodes",
"[",
"jump",
".",
"addr",
"]",
"if",
"jum... | Called when we cannot resolve an indirect jump.
:param IndirectJump jump: The unresolved indirect jump.
:return: None | [
"Called",
"when",
"we",
"cannot",
"resolve",
"an",
"indirect",
"jump",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2346-L2389 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._remove_redundant_overlapping_blocks | def _remove_redundant_overlapping_blocks(self):
"""
On some architectures there are sometimes garbage bytes (usually nops) between functions in order to properly
align the succeeding function. CFGFast does a linear sweeping which might create duplicated blocks for
function epilogues wher... | python | def _remove_redundant_overlapping_blocks(self):
"""
On some architectures there are sometimes garbage bytes (usually nops) between functions in order to properly
align the succeeding function. CFGFast does a linear sweeping which might create duplicated blocks for
function epilogues wher... | [
"def",
"_remove_redundant_overlapping_blocks",
"(",
"self",
")",
":",
"sorted_nodes",
"=",
"sorted",
"(",
"self",
".",
"graph",
".",
"nodes",
"(",
")",
",",
"key",
"=",
"lambda",
"n",
":",
"n",
".",
"addr",
"if",
"n",
"is",
"not",
"None",
"else",
"0",
... | On some architectures there are sometimes garbage bytes (usually nops) between functions in order to properly
align the succeeding function. CFGFast does a linear sweeping which might create duplicated blocks for
function epilogues where one block starts before the garbage bytes and the other starts aft... | [
"On",
"some",
"architectures",
"there",
"are",
"sometimes",
"garbage",
"bytes",
"(",
"usually",
"nops",
")",
"between",
"functions",
"in",
"order",
"to",
"properly",
"align",
"the",
"succeeding",
"function",
".",
"CFGFast",
"does",
"a",
"linear",
"sweeping",
"... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2393-L2580 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._remove_node | def _remove_node(self, node):
"""
Remove a CFGNode from self.graph as well as from the function manager (if it is the beginning of a function)
:param CFGNode node: The CFGNode to remove from the graph.
:return: None
"""
self.graph.remove_node(node)
if node.addr ... | python | def _remove_node(self, node):
"""
Remove a CFGNode from self.graph as well as from the function manager (if it is the beginning of a function)
:param CFGNode node: The CFGNode to remove from the graph.
:return: None
"""
self.graph.remove_node(node)
if node.addr ... | [
"def",
"_remove_node",
"(",
"self",
",",
"node",
")",
":",
"self",
".",
"graph",
".",
"remove_node",
"(",
"node",
")",
"if",
"node",
".",
"addr",
"in",
"self",
".",
"_nodes",
":",
"del",
"self",
".",
"_nodes",
"[",
"node",
".",
"addr",
"]",
"# We w... | Remove a CFGNode from self.graph as well as from the function manager (if it is the beginning of a function)
:param CFGNode node: The CFGNode to remove from the graph.
:return: None | [
"Remove",
"a",
"CFGNode",
"from",
"self",
".",
"graph",
"as",
"well",
"as",
"from",
"the",
"function",
"manager",
"(",
"if",
"it",
"is",
"the",
"beginning",
"of",
"a",
"function",
")"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2582-L2599 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._shrink_node | def _shrink_node(self, node, new_size, remove_function=True):
"""
Shrink the size of a node in CFG.
:param CFGNode node: The CFGNode to shrink
:param int new_size: The new size of the basic block
:param bool remove_function: If there is a function starting at `node`, should we r... | python | def _shrink_node(self, node, new_size, remove_function=True):
"""
Shrink the size of a node in CFG.
:param CFGNode node: The CFGNode to shrink
:param int new_size: The new size of the basic block
:param bool remove_function: If there is a function starting at `node`, should we r... | [
"def",
"_shrink_node",
"(",
"self",
",",
"node",
",",
"new_size",
",",
"remove_function",
"=",
"True",
")",
":",
"# Generate the new node",
"new_node",
"=",
"CFGNode",
"(",
"node",
".",
"addr",
",",
"new_size",
",",
"self",
".",
"model",
",",
"function_addre... | Shrink the size of a node in CFG.
:param CFGNode node: The CFGNode to shrink
:param int new_size: The new size of the basic block
:param bool remove_function: If there is a function starting at `node`, should we remove that function or not.
:return: None | [
"Shrink",
"the",
"size",
"of",
"a",
"node",
"in",
"CFG",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2601-L2682 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._analyze_all_function_features | def _analyze_all_function_features(self, all_funcs_completed=False):
"""
Iteratively analyze all changed functions, update their returning attribute, until a fix-point is reached (i.e.
no new returning/not-returning functions are found).
:return: None
"""
while True:
... | python | def _analyze_all_function_features(self, all_funcs_completed=False):
"""
Iteratively analyze all changed functions, update their returning attribute, until a fix-point is reached (i.e.
no new returning/not-returning functions are found).
:return: None
"""
while True:
... | [
"def",
"_analyze_all_function_features",
"(",
"self",
",",
"all_funcs_completed",
"=",
"False",
")",
":",
"while",
"True",
":",
"new_changes",
"=",
"self",
".",
"_iteratively_analyze_function_features",
"(",
"all_funcs_completed",
"=",
"all_funcs_completed",
")",
"new_r... | Iteratively analyze all changed functions, update their returning attribute, until a fix-point is reached (i.e.
no new returning/not-returning functions are found).
:return: None | [
"Iteratively",
"analyze",
"all",
"changed",
"functions",
"update",
"their",
"returning",
"attribute",
"until",
"a",
"fix",
"-",
"point",
"is",
"reached",
"(",
"i",
".",
"e",
".",
"no",
"new",
"returning",
"/",
"not",
"-",
"returning",
"functions",
"are",
"... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2687-L2738 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._graph_add_edge | def _graph_add_edge(self, cfg_node, src_node, src_jumpkind, src_ins_addr, src_stmt_idx):
"""
Add edge between nodes, or add node if entry point
:param CFGNode cfg_node: node which is jumped to
:param CFGNode src_node: node which is jumped from none if entry point
:param str src_... | python | def _graph_add_edge(self, cfg_node, src_node, src_jumpkind, src_ins_addr, src_stmt_idx):
"""
Add edge between nodes, or add node if entry point
:param CFGNode cfg_node: node which is jumped to
:param CFGNode src_node: node which is jumped from none if entry point
:param str src_... | [
"def",
"_graph_add_edge",
"(",
"self",
",",
"cfg_node",
",",
"src_node",
",",
"src_jumpkind",
",",
"src_ins_addr",
",",
"src_stmt_idx",
")",
":",
"if",
"src_node",
"is",
"None",
":",
"self",
".",
"graph",
".",
"add_node",
"(",
"cfg_node",
")",
"else",
":",... | Add edge between nodes, or add node if entry point
:param CFGNode cfg_node: node which is jumped to
:param CFGNode src_node: node which is jumped from none if entry point
:param str src_jumpkind: what type of jump the edge takes
:param int or str src_stmt_idx: source statements ID
... | [
"Add",
"edge",
"between",
"nodes",
"or",
"add",
"node",
"if",
"entry",
"point"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2750-L2765 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._make_return_edges | def _make_return_edges(self):
"""
For each returning function, create return edges in self.graph.
:return: None
"""
for func_addr, func in self.functions.items():
if func.returning is False:
continue
# get the node on CFG
if ... | python | def _make_return_edges(self):
"""
For each returning function, create return edges in self.graph.
:return: None
"""
for func_addr, func in self.functions.items():
if func.returning is False:
continue
# get the node on CFG
if ... | [
"def",
"_make_return_edges",
"(",
"self",
")",
":",
"for",
"func_addr",
",",
"func",
"in",
"self",
".",
"functions",
".",
"items",
"(",
")",
":",
"if",
"func",
".",
"returning",
"is",
"False",
":",
"continue",
"# get the node on CFG",
"if",
"func",
".",
... | For each returning function, create return edges in self.graph.
:return: None | [
"For",
"each",
"returning",
"function",
"create",
"return",
"edges",
"in",
"self",
".",
"graph",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2812-L2859 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._function_add_node | def _function_add_node(self, cfg_node, function_addr):
"""
Adds node to function manager, converting address to CodeNode if
possible
:param CFGNode cfg_node: A CFGNode instance.
:param int function_addr: Address of the current function.
:return: None
"""
... | python | def _function_add_node(self, cfg_node, function_addr):
"""
Adds node to function manager, converting address to CodeNode if
possible
:param CFGNode cfg_node: A CFGNode instance.
:param int function_addr: Address of the current function.
:return: None
"""
... | [
"def",
"_function_add_node",
"(",
"self",
",",
"cfg_node",
",",
"function_addr",
")",
":",
"snippet",
"=",
"self",
".",
"_to_snippet",
"(",
"cfg_node",
"=",
"cfg_node",
")",
"self",
".",
"kb",
".",
"functions",
".",
"_add_node",
"(",
"function_addr",
",",
... | Adds node to function manager, converting address to CodeNode if
possible
:param CFGNode cfg_node: A CFGNode instance.
:param int function_addr: Address of the current function.
:return: None | [
"Adds",
"node",
"to",
"function",
"manager",
"converting",
"address",
"to",
"CodeNode",
"if",
"possible"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2865-L2875 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._function_add_transition_edge | def _function_add_transition_edge(self, dst_addr, src_node, src_func_addr, to_outside=False, dst_func_addr=None,
stmt_idx=None, ins_addr=None):
"""
Add a transition edge to the function transiton map.
:param int dst_addr: Address that the control flow trans... | python | def _function_add_transition_edge(self, dst_addr, src_node, src_func_addr, to_outside=False, dst_func_addr=None,
stmt_idx=None, ins_addr=None):
"""
Add a transition edge to the function transiton map.
:param int dst_addr: Address that the control flow trans... | [
"def",
"_function_add_transition_edge",
"(",
"self",
",",
"dst_addr",
",",
"src_node",
",",
"src_func_addr",
",",
"to_outside",
"=",
"False",
",",
"dst_func_addr",
"=",
"None",
",",
"stmt_idx",
"=",
"None",
",",
"ins_addr",
"=",
"None",
")",
":",
"try",
":",... | Add a transition edge to the function transiton map.
:param int dst_addr: Address that the control flow transits to.
:param CFGNode src_node: The source node that the control flow transits from.
:param int src_func_addr: Function address.
:return: True if the edge is correctly added. Fa... | [
"Add",
"a",
"transition",
"edge",
"to",
"the",
"function",
"transiton",
"map",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2877-L2913 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._function_add_call_edge | def _function_add_call_edge(self, addr, src_node, function_addr, syscall=False, stmt_idx=None, ins_addr=None):
"""
Add a call edge to the function transition map.
:param int addr: Address that is being called (callee).
:param CFGNode src_node: The source CFG node (caller).
:para... | python | def _function_add_call_edge(self, addr, src_node, function_addr, syscall=False, stmt_idx=None, ins_addr=None):
"""
Add a call edge to the function transition map.
:param int addr: Address that is being called (callee).
:param CFGNode src_node: The source CFG node (caller).
:para... | [
"def",
"_function_add_call_edge",
"(",
"self",
",",
"addr",
",",
"src_node",
",",
"function_addr",
",",
"syscall",
"=",
"False",
",",
"stmt_idx",
"=",
"None",
",",
"ins_addr",
"=",
"None",
")",
":",
"try",
":",
"if",
"src_node",
"is",
"None",
":",
"self"... | Add a call edge to the function transition map.
:param int addr: Address that is being called (callee).
:param CFGNode src_node: The source CFG node (caller).
:param int ret_addr: Address that returns to (in case the function returns).
:param int function_addr: Function address..
... | [
"Add",
"a",
"call",
"edge",
"to",
"the",
"function",
"transition",
"map",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2915-L2945 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._function_add_fakeret_edge | def _function_add_fakeret_edge(self, addr, src_node, src_func_addr, confirmed=None):
"""
Generate CodeNodes for target and source, if no source node add node
for function, otherwise creates fake return to in function manager
:param int addr: target address
:param angr.analyses.C... | python | def _function_add_fakeret_edge(self, addr, src_node, src_func_addr, confirmed=None):
"""
Generate CodeNodes for target and source, if no source node add node
for function, otherwise creates fake return to in function manager
:param int addr: target address
:param angr.analyses.C... | [
"def",
"_function_add_fakeret_edge",
"(",
"self",
",",
"addr",
",",
"src_node",
",",
"src_func_addr",
",",
"confirmed",
"=",
"None",
")",
":",
"target_node",
"=",
"self",
".",
"_nodes",
".",
"get",
"(",
"addr",
",",
"None",
")",
"if",
"target_node",
"is",
... | Generate CodeNodes for target and source, if no source node add node
for function, otherwise creates fake return to in function manager
:param int addr: target address
:param angr.analyses.CFGNode src_node: source node
:param int src_func_addr: address of function
:param confirm... | [
"Generate",
"CodeNodes",
"for",
"target",
"and",
"source",
"if",
"no",
"source",
"node",
"add",
"node",
"for",
"function",
"otherwise",
"creates",
"fake",
"return",
"to",
"in",
"function",
"manager"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2947-L2969 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._function_add_return_site | def _function_add_return_site(self, addr, function_addr):
"""
Generate CodeNodes for target address, registers node for function to
function manager as return site
:param int addr: target address
:param int function_addr: address of function
:return: None
"""
... | python | def _function_add_return_site(self, addr, function_addr):
"""
Generate CodeNodes for target address, registers node for function to
function manager as return site
:param int addr: target address
:param int function_addr: address of function
:return: None
"""
... | [
"def",
"_function_add_return_site",
"(",
"self",
",",
"addr",
",",
"function_addr",
")",
":",
"try",
":",
"target",
"=",
"self",
".",
"_to_snippet",
"(",
"self",
".",
"_nodes",
"[",
"addr",
"]",
")",
"except",
"KeyError",
":",
"target",
"=",
"addr",
"sel... | Generate CodeNodes for target address, registers node for function to
function manager as return site
:param int addr: target address
:param int function_addr: address of function
:return: None | [
"Generate",
"CodeNodes",
"for",
"target",
"address",
"registers",
"node",
"for",
"function",
"to",
"function",
"manager",
"as",
"return",
"site"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2971-L2985 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._function_add_return_edge | def _function_add_return_edge(self, return_from_addr, return_to_addr, function_addr):
"""
Generate CodeNodes for return_to_addr, add this node for function to
function manager generating new edge
:param int return_from_addr: target address
:param int return_to_addr: target addre... | python | def _function_add_return_edge(self, return_from_addr, return_to_addr, function_addr):
"""
Generate CodeNodes for return_to_addr, add this node for function to
function manager generating new edge
:param int return_from_addr: target address
:param int return_to_addr: target addre... | [
"def",
"_function_add_return_edge",
"(",
"self",
",",
"return_from_addr",
",",
"return_to_addr",
",",
"function_addr",
")",
":",
"return_to_node",
"=",
"self",
".",
"_nodes",
".",
"get",
"(",
"return_to_addr",
",",
"None",
")",
"if",
"return_to_node",
"is",
"Non... | Generate CodeNodes for return_to_addr, add this node for function to
function manager generating new edge
:param int return_from_addr: target address
:param int return_to_addr: target address
:param int function_addr: address of function
:return: None | [
"Generate",
"CodeNodes",
"for",
"return_to_addr",
"add",
"this",
"node",
"for",
"function",
"to",
"function",
"manager",
"generating",
"new",
"edge"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L2987-L3007 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._arm_track_lr_on_stack | def _arm_track_lr_on_stack(self, addr, irsb, function):
"""
At the beginning of the basic block, we check if the first instruction stores the LR register onto the stack.
If it does, we calculate the offset of that store, and record the offset in function.info.
For instance, here is the ... | python | def _arm_track_lr_on_stack(self, addr, irsb, function):
"""
At the beginning of the basic block, we check if the first instruction stores the LR register onto the stack.
If it does, we calculate the offset of that store, and record the offset in function.info.
For instance, here is the ... | [
"def",
"_arm_track_lr_on_stack",
"(",
"self",
",",
"addr",
",",
"irsb",
",",
"function",
")",
":",
"if",
"irsb",
".",
"statements",
"is",
"None",
":",
"return",
"if",
"'lr_saved_on_stack'",
"in",
"function",
".",
"info",
":",
"return",
"# if it does, we log it... | At the beginning of the basic block, we check if the first instruction stores the LR register onto the stack.
If it does, we calculate the offset of that store, and record the offset in function.info.
For instance, here is the disassembly of a THUMB mode function:
000007E4 STR.W LR,... | [
"At",
"the",
"beginning",
"of",
"the",
"basic",
"block",
"we",
"check",
"if",
"the",
"first",
"instruction",
"stores",
"the",
"LR",
"register",
"onto",
"the",
"stack",
".",
"If",
"it",
"does",
"we",
"calculate",
"the",
"offset",
"of",
"that",
"store",
"a... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L3013-L3099 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._arm_track_read_lr_from_stack | def _arm_track_read_lr_from_stack(self, irsb, function): # pylint:disable=unused-argument
"""
At the end of a basic block, simulate the very last instruction to see if the return address is read from the
stack and written in PC. If so, the jumpkind of this IRSB will be set to Ijk_Ret. For detai... | python | def _arm_track_read_lr_from_stack(self, irsb, function): # pylint:disable=unused-argument
"""
At the end of a basic block, simulate the very last instruction to see if the return address is read from the
stack and written in PC. If so, the jumpkind of this IRSB will be set to Ijk_Ret. For detai... | [
"def",
"_arm_track_read_lr_from_stack",
"(",
"self",
",",
"irsb",
",",
"function",
")",
":",
"# pylint:disable=unused-argument",
"if",
"'lr_saved_on_stack'",
"not",
"in",
"function",
".",
"info",
"or",
"not",
"function",
".",
"info",
"[",
"'lr_saved_on_stack'",
"]",... | At the end of a basic block, simulate the very last instruction to see if the return address is read from the
stack and written in PC. If so, the jumpkind of this IRSB will be set to Ijk_Ret. For detailed explanations,
please see the documentation of _arm_track_lr_on_stack().
:param pyvex.IRSB ... | [
"At",
"the",
"end",
"of",
"a",
"basic",
"block",
"simulate",
"the",
"very",
"last",
"instruction",
"to",
"see",
"if",
"the",
"return",
"address",
"is",
"read",
"from",
"the",
"stack",
"and",
"written",
"in",
"PC",
".",
"If",
"so",
"the",
"jumpkind",
"o... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L3101-L3157 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._generate_cfgnode | def _generate_cfgnode(self, cfg_job, current_function_addr):
"""
Generate a CFGNode that starts at `cfg_job.addr`.
Since lifting machine code to IRSBs is slow, self._nodes is used as a cache of CFGNodes.
If the current architecture is ARM, this method will try to lift the block in the ... | python | def _generate_cfgnode(self, cfg_job, current_function_addr):
"""
Generate a CFGNode that starts at `cfg_job.addr`.
Since lifting machine code to IRSBs is slow, self._nodes is used as a cache of CFGNodes.
If the current architecture is ARM, this method will try to lift the block in the ... | [
"def",
"_generate_cfgnode",
"(",
"self",
",",
"cfg_job",
",",
"current_function_addr",
")",
":",
"addr",
"=",
"cfg_job",
".",
"addr",
"try",
":",
"if",
"addr",
"in",
"self",
".",
"_nodes",
":",
"cfg_node",
"=",
"self",
".",
"_nodes",
"[",
"addr",
"]",
... | Generate a CFGNode that starts at `cfg_job.addr`.
Since lifting machine code to IRSBs is slow, self._nodes is used as a cache of CFGNodes.
If the current architecture is ARM, this method will try to lift the block in the mode specified by the address
(determined by the parity of the address: e... | [
"Generate",
"a",
"CFGNode",
"that",
"starts",
"at",
"cfg_job",
".",
"addr",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L3163-L3333 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast._process_block_arch_specific | def _process_block_arch_specific(self, addr, irsb, func_addr): # pylint: disable=unused-argument
"""
According to arch types ['ARMEL', 'ARMHF', 'MIPS32'] does different
fixes
For ARM deals with link register on the stack
(see _arm_track_lr_on_stack)
For MIPS32 simulates... | python | def _process_block_arch_specific(self, addr, irsb, func_addr): # pylint: disable=unused-argument
"""
According to arch types ['ARMEL', 'ARMHF', 'MIPS32'] does different
fixes
For ARM deals with link register on the stack
(see _arm_track_lr_on_stack)
For MIPS32 simulates... | [
"def",
"_process_block_arch_specific",
"(",
"self",
",",
"addr",
",",
"irsb",
",",
"func_addr",
")",
":",
"# pylint: disable=unused-argument",
"if",
"is_arm_arch",
"(",
"self",
".",
"project",
".",
"arch",
")",
":",
"if",
"self",
".",
"_arch_options",
".",
"re... | According to arch types ['ARMEL', 'ARMHF', 'MIPS32'] does different
fixes
For ARM deals with link register on the stack
(see _arm_track_lr_on_stack)
For MIPS32 simulates a new state where the global pointer is 0xffffffff
from current address after three steps if the first succes... | [
"According",
"to",
"arch",
"types",
"[",
"ARMEL",
"ARMHF",
"MIPS32",
"]",
"does",
"different",
"fixes"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L3335-L3402 | train |
angr/angr | angr/analyses/cfg/cfg_fast.py | CFGFast.generate_code_cover | def generate_code_cover(self):
"""
Generate a list of all recovered basic blocks.
"""
lst = []
for cfg_node in self.graph.nodes():
size = cfg_node.size
lst.append((cfg_node.addr, size))
lst = sorted(lst, key=lambda x: x[0])
return lst | python | def generate_code_cover(self):
"""
Generate a list of all recovered basic blocks.
"""
lst = []
for cfg_node in self.graph.nodes():
size = cfg_node.size
lst.append((cfg_node.addr, size))
lst = sorted(lst, key=lambda x: x[0])
return lst | [
"def",
"generate_code_cover",
"(",
"self",
")",
":",
"lst",
"=",
"[",
"]",
"for",
"cfg_node",
"in",
"self",
".",
"graph",
".",
"nodes",
"(",
")",
":",
"size",
"=",
"cfg_node",
".",
"size",
"lst",
".",
"append",
"(",
"(",
"cfg_node",
".",
"addr",
",... | Generate a list of all recovered basic blocks. | [
"Generate",
"a",
"list",
"of",
"all",
"recovered",
"basic",
"blocks",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/cfg_fast.py#L3445-L3456 | train |
angr/angr | angr/sim_state.py | SimState.se | def se(self):
"""
Deprecated alias for `solver`
"""
global _complained_se
if not _complained_se:
_complained_se = True
l.critical("The name state.se is deprecated; please use state.solver.")
return self.get_plugin('solver') | python | def se(self):
"""
Deprecated alias for `solver`
"""
global _complained_se
if not _complained_se:
_complained_se = True
l.critical("The name state.se is deprecated; please use state.solver.")
return self.get_plugin('solver') | [
"def",
"se",
"(",
"self",
")",
":",
"global",
"_complained_se",
"if",
"not",
"_complained_se",
":",
"_complained_se",
"=",
"True",
"l",
".",
"critical",
"(",
"\"The name state.se is deprecated; please use state.solver.\"",
")",
"return",
"self",
".",
"get_plugin",
"... | Deprecated alias for `solver` | [
"Deprecated",
"alias",
"for",
"solver"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L241-L249 | train |
angr/angr | angr/sim_state.py | SimState.addr | def addr(self):
"""
Get the concrete address of the instruction pointer, without triggering SimInspect breakpoints or generating
SimActions. An integer is returned, or an exception is raised if the instruction pointer is symbolic.
:return: an int
"""
ip = self.regs._ip
... | python | def addr(self):
"""
Get the concrete address of the instruction pointer, without triggering SimInspect breakpoints or generating
SimActions. An integer is returned, or an exception is raised if the instruction pointer is symbolic.
:return: an int
"""
ip = self.regs._ip
... | [
"def",
"addr",
"(",
"self",
")",
":",
"ip",
"=",
"self",
".",
"regs",
".",
"_ip",
"if",
"isinstance",
"(",
"ip",
",",
"SootAddressDescriptor",
")",
":",
"return",
"ip",
"return",
"self",
".",
"solver",
".",
"eval_one",
"(",
"self",
".",
"regs",
".",
... | Get the concrete address of the instruction pointer, without triggering SimInspect breakpoints or generating
SimActions. An integer is returned, or an exception is raised if the instruction pointer is symbolic.
:return: an int | [
"Get",
"the",
"concrete",
"address",
"of",
"the",
"instruction",
"pointer",
"without",
"triggering",
"SimInspect",
"breakpoints",
"or",
"generating",
"SimActions",
".",
"An",
"integer",
"is",
"returned",
"or",
"an",
"exception",
"is",
"raised",
"if",
"the",
"ins... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L286-L297 | train |
angr/angr | angr/sim_state.py | SimState.add_constraints | def add_constraints(self, *args, **kwargs):
"""
Add some constraints to the state.
You may pass in any number of symbolic booleans as variadic positional arguments.
"""
if len(args) > 0 and isinstance(args[0], (list, tuple)):
raise Exception("Tuple or list passed to ... | python | def add_constraints(self, *args, **kwargs):
"""
Add some constraints to the state.
You may pass in any number of symbolic booleans as variadic positional arguments.
"""
if len(args) > 0 and isinstance(args[0], (list, tuple)):
raise Exception("Tuple or list passed to ... | [
"def",
"add_constraints",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"len",
"(",
"args",
")",
">",
"0",
"and",
"isinstance",
"(",
"args",
"[",
"0",
"]",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"raise",
"Excep... | Add some constraints to the state.
You may pass in any number of symbolic booleans as variadic positional arguments. | [
"Add",
"some",
"constraints",
"to",
"the",
"state",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L428-L507 | train |
angr/angr | angr/sim_state.py | SimState.satisfiable | def satisfiable(self, **kwargs):
"""
Whether the state's constraints are satisfiable
"""
if o.ABSTRACT_SOLVER in self.options or o.SYMBOLIC not in self.options:
extra_constraints = kwargs.pop('extra_constraints', ())
for e in extra_constraints:
if ... | python | def satisfiable(self, **kwargs):
"""
Whether the state's constraints are satisfiable
"""
if o.ABSTRACT_SOLVER in self.options or o.SYMBOLIC not in self.options:
extra_constraints = kwargs.pop('extra_constraints', ())
for e in extra_constraints:
if ... | [
"def",
"satisfiable",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"o",
".",
"ABSTRACT_SOLVER",
"in",
"self",
".",
"options",
"or",
"o",
".",
"SYMBOLIC",
"not",
"in",
"self",
".",
"options",
":",
"extra_constraints",
"=",
"kwargs",
".",
"pop",... | Whether the state's constraints are satisfiable | [
"Whether",
"the",
"state",
"s",
"constraints",
"are",
"satisfiable"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L509-L521 | train |
angr/angr | angr/sim_state.py | SimState.block | def block(self, *args, **kwargs):
"""
Represent the basic block at this state's instruction pointer.
Any arguments to `AngrObjectFactory.block` can ba passed to this.
:return: A Block object describing the basic block of code at this point.
"""
if not args and 'addr' not... | python | def block(self, *args, **kwargs):
"""
Represent the basic block at this state's instruction pointer.
Any arguments to `AngrObjectFactory.block` can ba passed to this.
:return: A Block object describing the basic block of code at this point.
"""
if not args and 'addr' not... | [
"def",
"block",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"not",
"args",
"and",
"'addr'",
"not",
"in",
"kwargs",
":",
"kwargs",
"[",
"'addr'",
"]",
"=",
"self",
".",
"addr",
"return",
"self",
".",
"project",
".",
"fa... | Represent the basic block at this state's instruction pointer.
Any arguments to `AngrObjectFactory.block` can ba passed to this.
:return: A Block object describing the basic block of code at this point. | [
"Represent",
"the",
"basic",
"block",
"at",
"this",
"state",
"s",
"instruction",
"pointer",
".",
"Any",
"arguments",
"to",
"AngrObjectFactory",
".",
"block",
"can",
"ba",
"passed",
"to",
"this",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L544-L553 | train |
angr/angr | angr/sim_state.py | SimState.copy | def copy(self):
"""
Returns a copy of the state.
"""
if self._global_condition is not None:
raise SimStateError("global condition was not cleared before state.copy().")
c_plugins = self._copy_plugins()
state = SimState(project=self.project, arch=self.arch, p... | python | def copy(self):
"""
Returns a copy of the state.
"""
if self._global_condition is not None:
raise SimStateError("global condition was not cleared before state.copy().")
c_plugins = self._copy_plugins()
state = SimState(project=self.project, arch=self.arch, p... | [
"def",
"copy",
"(",
"self",
")",
":",
"if",
"self",
".",
"_global_condition",
"is",
"not",
"None",
":",
"raise",
"SimStateError",
"(",
"\"global condition was not cleared before state.copy().\"",
")",
"c_plugins",
"=",
"self",
".",
"_copy_plugins",
"(",
")",
"stat... | Returns a copy of the state. | [
"Returns",
"a",
"copy",
"of",
"the",
"state",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L568-L587 | train |
angr/angr | angr/sim_state.py | SimState.merge | def merge(self, *others, **kwargs):
"""
Merges this state with the other states. Returns the merging result, merged state, and the merge flag.
:param states: the states to merge
:param merge_conditions: a tuple of the conditions under which each state holds
:param common_ancesto... | python | def merge(self, *others, **kwargs):
"""
Merges this state with the other states. Returns the merging result, merged state, and the merge flag.
:param states: the states to merge
:param merge_conditions: a tuple of the conditions under which each state holds
:param common_ancesto... | [
"def",
"merge",
"(",
"self",
",",
"*",
"others",
",",
"*",
"*",
"kwargs",
")",
":",
"merge_conditions",
"=",
"kwargs",
".",
"pop",
"(",
"'merge_conditions'",
",",
"None",
")",
"common_ancestor",
"=",
"kwargs",
".",
"pop",
"(",
"'common_ancestor'",
",",
"... | Merges this state with the other states. Returns the merging result, merged state, and the merge flag.
:param states: the states to merge
:param merge_conditions: a tuple of the conditions under which each state holds
:param common_ancestor: a state that represents the common history between t... | [
"Merges",
"this",
"state",
"with",
"the",
"other",
"states",
".",
"Returns",
"the",
"merging",
"result",
"merged",
"state",
"and",
"the",
"merge",
"flag",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L589-L680 | train |
angr/angr | angr/sim_state.py | SimState.widen | def widen(self, *others):
"""
Perform a widening between self and other states
:param others:
:return:
"""
if len(set(frozenset(o.plugins.keys()) for o in others)) != 1:
raise SimMergeError("Unable to widen due to different sets of plugins.")
if len(s... | python | def widen(self, *others):
"""
Perform a widening between self and other states
:param others:
:return:
"""
if len(set(frozenset(o.plugins.keys()) for o in others)) != 1:
raise SimMergeError("Unable to widen due to different sets of plugins.")
if len(s... | [
"def",
"widen",
"(",
"self",
",",
"*",
"others",
")",
":",
"if",
"len",
"(",
"set",
"(",
"frozenset",
"(",
"o",
".",
"plugins",
".",
"keys",
"(",
")",
")",
"for",
"o",
"in",
"others",
")",
")",
"!=",
"1",
":",
"raise",
"SimMergeError",
"(",
"\"... | Perform a widening between self and other states
:param others:
:return: | [
"Perform",
"a",
"widening",
"between",
"self",
"and",
"other",
"states",
":",
"param",
"others",
":",
":",
"return",
":"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L682-L706 | train |
angr/angr | angr/sim_state.py | SimState.reg_concrete | def reg_concrete(self, *args, **kwargs):
"""
Returns the contents of a register but, if that register is symbolic,
raises a SimValueError.
"""
e = self.registers.load(*args, **kwargs)
if self.solver.symbolic(e):
raise SimValueError("target of reg_concrete is s... | python | def reg_concrete(self, *args, **kwargs):
"""
Returns the contents of a register but, if that register is symbolic,
raises a SimValueError.
"""
e = self.registers.load(*args, **kwargs)
if self.solver.symbolic(e):
raise SimValueError("target of reg_concrete is s... | [
"def",
"reg_concrete",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"e",
"=",
"self",
".",
"registers",
".",
"load",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"if",
"self",
".",
"solver",
".",
"symbolic",
"(",
"e",
")... | Returns the contents of a register but, if that register is symbolic,
raises a SimValueError. | [
"Returns",
"the",
"contents",
"of",
"a",
"register",
"but",
"if",
"that",
"register",
"is",
"symbolic",
"raises",
"a",
"SimValueError",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L712-L720 | train |
angr/angr | angr/sim_state.py | SimState.mem_concrete | def mem_concrete(self, *args, **kwargs):
"""
Returns the contents of a memory but, if the contents are symbolic,
raises a SimValueError.
"""
e = self.memory.load(*args, **kwargs)
if self.solver.symbolic(e):
raise SimValueError("target of mem_concrete is symbol... | python | def mem_concrete(self, *args, **kwargs):
"""
Returns the contents of a memory but, if the contents are symbolic,
raises a SimValueError.
"""
e = self.memory.load(*args, **kwargs)
if self.solver.symbolic(e):
raise SimValueError("target of mem_concrete is symbol... | [
"def",
"mem_concrete",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"e",
"=",
"self",
".",
"memory",
".",
"load",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"if",
"self",
".",
"solver",
".",
"symbolic",
"(",
"e",
")",
... | Returns the contents of a memory but, if the contents are symbolic,
raises a SimValueError. | [
"Returns",
"the",
"contents",
"of",
"a",
"memory",
"but",
"if",
"the",
"contents",
"are",
"symbolic",
"raises",
"a",
"SimValueError",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L722-L730 | train |
angr/angr | angr/sim_state.py | SimState.stack_push | def stack_push(self, thing):
"""
Push 'thing' to the stack, writing the thing to memory and adjusting the stack pointer.
"""
# increment sp
sp = self.regs.sp + self.arch.stack_change
self.regs.sp = sp
return self.memory.store(sp, thing, endness=self.arch.memory_en... | python | def stack_push(self, thing):
"""
Push 'thing' to the stack, writing the thing to memory and adjusting the stack pointer.
"""
# increment sp
sp = self.regs.sp + self.arch.stack_change
self.regs.sp = sp
return self.memory.store(sp, thing, endness=self.arch.memory_en... | [
"def",
"stack_push",
"(",
"self",
",",
"thing",
")",
":",
"# increment sp",
"sp",
"=",
"self",
".",
"regs",
".",
"sp",
"+",
"self",
".",
"arch",
".",
"stack_change",
"self",
".",
"regs",
".",
"sp",
"=",
"sp",
"return",
"self",
".",
"memory",
".",
"... | Push 'thing' to the stack, writing the thing to memory and adjusting the stack pointer. | [
"Push",
"thing",
"to",
"the",
"stack",
"writing",
"the",
"thing",
"to",
"memory",
"and",
"adjusting",
"the",
"stack",
"pointer",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L737-L744 | train |
angr/angr | angr/sim_state.py | SimState.stack_pop | def stack_pop(self):
"""
Pops from the stack and returns the popped thing. The length will be the architecture word size.
"""
sp = self.regs.sp
self.regs.sp = sp - self.arch.stack_change
return self.memory.load(sp, self.arch.bytes, endness=self.arch.memory_endness) | python | def stack_pop(self):
"""
Pops from the stack and returns the popped thing. The length will be the architecture word size.
"""
sp = self.regs.sp
self.regs.sp = sp - self.arch.stack_change
return self.memory.load(sp, self.arch.bytes, endness=self.arch.memory_endness) | [
"def",
"stack_pop",
"(",
"self",
")",
":",
"sp",
"=",
"self",
".",
"regs",
".",
"sp",
"self",
".",
"regs",
".",
"sp",
"=",
"sp",
"-",
"self",
".",
"arch",
".",
"stack_change",
"return",
"self",
".",
"memory",
".",
"load",
"(",
"sp",
",",
"self",
... | Pops from the stack and returns the popped thing. The length will be the architecture word size. | [
"Pops",
"from",
"the",
"stack",
"and",
"returns",
"the",
"popped",
"thing",
".",
"The",
"length",
"will",
"be",
"the",
"architecture",
"word",
"size",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L747-L753 | train |
angr/angr | angr/sim_state.py | SimState.stack_read | def stack_read(self, offset, length, bp=False):
"""
Reads length bytes, at an offset into the stack.
:param offset: The offset from the stack pointer.
:param length: The number of bytes to read.
:param bp: If True, offset from the BP instead of the SP. Default: False.
... | python | def stack_read(self, offset, length, bp=False):
"""
Reads length bytes, at an offset into the stack.
:param offset: The offset from the stack pointer.
:param length: The number of bytes to read.
:param bp: If True, offset from the BP instead of the SP. Default: False.
... | [
"def",
"stack_read",
"(",
"self",
",",
"offset",
",",
"length",
",",
"bp",
"=",
"False",
")",
":",
"sp",
"=",
"self",
".",
"regs",
".",
"bp",
"if",
"bp",
"else",
"self",
".",
"regs",
".",
"sp",
"return",
"self",
".",
"memory",
".",
"load",
"(",
... | Reads length bytes, at an offset into the stack.
:param offset: The offset from the stack pointer.
:param length: The number of bytes to read.
:param bp: If True, offset from the BP instead of the SP. Default: False. | [
"Reads",
"length",
"bytes",
"at",
"an",
"offset",
"into",
"the",
"stack",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L756-L765 | train |
angr/angr | angr/sim_state.py | SimState._stack_values_to_string | def _stack_values_to_string(self, stack_values):
"""
Convert each stack value to a string
:param stack_values: A list of values
:return: The converted string
"""
strings = [ ]
for stack_value in stack_values:
if self.solver.symbolic(stack_value):
... | python | def _stack_values_to_string(self, stack_values):
"""
Convert each stack value to a string
:param stack_values: A list of values
:return: The converted string
"""
strings = [ ]
for stack_value in stack_values:
if self.solver.symbolic(stack_value):
... | [
"def",
"_stack_values_to_string",
"(",
"self",
",",
"stack_values",
")",
":",
"strings",
"=",
"[",
"]",
"for",
"stack_value",
"in",
"stack_values",
":",
"if",
"self",
".",
"solver",
".",
"symbolic",
"(",
"stack_value",
")",
":",
"concretized_value",
"=",
"\"... | Convert each stack value to a string
:param stack_values: A list of values
:return: The converted string | [
"Convert",
"each",
"stack",
"value",
"to",
"a",
"string"
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L788-L807 | train |
angr/angr | angr/sim_state.py | SimState.dbg_print_stack | def dbg_print_stack(self, depth=None, sp=None):
"""
Only used for debugging purposes.
Return the current stack info in formatted string. If depth is None, the
current stack frame (from sp to bp) will be printed out.
"""
var_size = self.arch.bytes
sp_sim = self.re... | python | def dbg_print_stack(self, depth=None, sp=None):
"""
Only used for debugging purposes.
Return the current stack info in formatted string. If depth is None, the
current stack frame (from sp to bp) will be printed out.
"""
var_size = self.arch.bytes
sp_sim = self.re... | [
"def",
"dbg_print_stack",
"(",
"self",
",",
"depth",
"=",
"None",
",",
"sp",
"=",
"None",
")",
":",
"var_size",
"=",
"self",
".",
"arch",
".",
"bytes",
"sp_sim",
"=",
"self",
".",
"regs",
".",
"_sp",
"bp_sim",
"=",
"self",
".",
"regs",
".",
"_bp",
... | Only used for debugging purposes.
Return the current stack info in formatted string. If depth is None, the
current stack frame (from sp to bp) will be printed out. | [
"Only",
"used",
"for",
"debugging",
"purposes",
".",
"Return",
"the",
"current",
"stack",
"info",
"in",
"formatted",
"string",
".",
"If",
"depth",
"is",
"None",
"the",
"current",
"stack",
"frame",
"(",
"from",
"sp",
"to",
"bp",
")",
"will",
"be",
"printe... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/sim_state.py#L809-L862 | train |
angr/angr | angr/state_plugins/heap/heap_base.py | SimHeapBase._conc_alloc_size | def _conc_alloc_size(self, sim_size):
"""
Concretizes a size argument, if necessary, to something that makes sense when allocating space. Here we just
maximize its potential size up to the maximum variable size specified in the libc plugin.
TODO:
Further consideration of the tra... | python | def _conc_alloc_size(self, sim_size):
"""
Concretizes a size argument, if necessary, to something that makes sense when allocating space. Here we just
maximize its potential size up to the maximum variable size specified in the libc plugin.
TODO:
Further consideration of the tra... | [
"def",
"_conc_alloc_size",
"(",
"self",
",",
"sim_size",
")",
":",
"if",
"self",
".",
"state",
".",
"solver",
".",
"symbolic",
"(",
"sim_size",
")",
":",
"size",
"=",
"self",
".",
"state",
".",
"solver",
".",
"max_int",
"(",
"sim_size",
")",
"if",
"s... | Concretizes a size argument, if necessary, to something that makes sense when allocating space. Here we just
maximize its potential size up to the maximum variable size specified in the libc plugin.
TODO:
Further consideration of the tradeoffs of this approach is probably warranted. SimHeapPTMa... | [
"Concretizes",
"a",
"size",
"argument",
"if",
"necessary",
"to",
"something",
"that",
"makes",
"sense",
"when",
"allocating",
"space",
".",
"Here",
"we",
"just",
"maximize",
"its",
"potential",
"size",
"up",
"to",
"the",
"maximum",
"variable",
"size",
"specifi... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/heap/heap_base.py#L33-L66 | train |
angr/angr | angr/state_plugins/heap/heap_base.py | SimHeapBase._malloc | def _malloc(self, sim_size):
"""
Handler for any libc `malloc` SimProcedure call. If the heap has faithful support for `malloc`, it ought to be
implemented in a `malloc` function (as opposed to the `_malloc` function).
:param sim_size: the amount of memory (in bytes) to be allocated
... | python | def _malloc(self, sim_size):
"""
Handler for any libc `malloc` SimProcedure call. If the heap has faithful support for `malloc`, it ought to be
implemented in a `malloc` function (as opposed to the `_malloc` function).
:param sim_size: the amount of memory (in bytes) to be allocated
... | [
"def",
"_malloc",
"(",
"self",
",",
"sim_size",
")",
":",
"raise",
"NotImplementedError",
"(",
"\"%s not implemented for %s\"",
"%",
"(",
"self",
".",
"_malloc",
".",
"__func__",
".",
"__name__",
",",
"self",
".",
"__class__",
".",
"__name__",
")",
")"
] | Handler for any libc `malloc` SimProcedure call. If the heap has faithful support for `malloc`, it ought to be
implemented in a `malloc` function (as opposed to the `_malloc` function).
:param sim_size: the amount of memory (in bytes) to be allocated | [
"Handler",
"for",
"any",
"libc",
"malloc",
"SimProcedure",
"call",
".",
"If",
"the",
"heap",
"has",
"faithful",
"support",
"for",
"malloc",
"it",
"ought",
"to",
"be",
"implemented",
"in",
"a",
"malloc",
"function",
"(",
"as",
"opposed",
"to",
"the",
"_mall... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/heap/heap_base.py#L68-L76 | train |
angr/angr | angr/state_plugins/heap/heap_base.py | SimHeapBase._free | def _free(self, ptr):
"""
Handler for any libc `free` SimProcedure call. If the heap has faithful support for `free`, it ought to be
implemented in a `free` function (as opposed to the `_free` function).
:param ptr: the location in memory to be freed
"""
raise NotImpleme... | python | def _free(self, ptr):
"""
Handler for any libc `free` SimProcedure call. If the heap has faithful support for `free`, it ought to be
implemented in a `free` function (as opposed to the `_free` function).
:param ptr: the location in memory to be freed
"""
raise NotImpleme... | [
"def",
"_free",
"(",
"self",
",",
"ptr",
")",
":",
"raise",
"NotImplementedError",
"(",
"\"%s not implemented for %s\"",
"%",
"(",
"self",
".",
"_free",
".",
"__func__",
".",
"__name__",
",",
"self",
".",
"__class__",
".",
"__name__",
")",
")"
] | Handler for any libc `free` SimProcedure call. If the heap has faithful support for `free`, it ought to be
implemented in a `free` function (as opposed to the `_free` function).
:param ptr: the location in memory to be freed | [
"Handler",
"for",
"any",
"libc",
"free",
"SimProcedure",
"call",
".",
"If",
"the",
"heap",
"has",
"faithful",
"support",
"for",
"free",
"it",
"ought",
"to",
"be",
"implemented",
"in",
"a",
"free",
"function",
"(",
"as",
"opposed",
"to",
"the",
"_free",
"... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/heap/heap_base.py#L78-L86 | train |
angr/angr | angr/state_plugins/heap/heap_base.py | SimHeapBase._calloc | def _calloc(self, sim_nmemb, sim_size):
"""
Handler for any libc `calloc` SimProcedure call. If the heap has faithful support for `calloc`, it ought to be
implemented in a `calloc` function (as opposed to the `_calloc` function).
:param sim_nmemb: the number of elements to allocated
... | python | def _calloc(self, sim_nmemb, sim_size):
"""
Handler for any libc `calloc` SimProcedure call. If the heap has faithful support for `calloc`, it ought to be
implemented in a `calloc` function (as opposed to the `_calloc` function).
:param sim_nmemb: the number of elements to allocated
... | [
"def",
"_calloc",
"(",
"self",
",",
"sim_nmemb",
",",
"sim_size",
")",
":",
"raise",
"NotImplementedError",
"(",
"\"%s not implemented for %s\"",
"%",
"(",
"self",
".",
"_calloc",
".",
"__func__",
".",
"__name__",
",",
"self",
".",
"__class__",
".",
"__name__"... | Handler for any libc `calloc` SimProcedure call. If the heap has faithful support for `calloc`, it ought to be
implemented in a `calloc` function (as opposed to the `_calloc` function).
:param sim_nmemb: the number of elements to allocated
:param sim_size: the size of each element (in bytes) | [
"Handler",
"for",
"any",
"libc",
"calloc",
"SimProcedure",
"call",
".",
"If",
"the",
"heap",
"has",
"faithful",
"support",
"for",
"calloc",
"it",
"ought",
"to",
"be",
"implemented",
"in",
"a",
"calloc",
"function",
"(",
"as",
"opposed",
"to",
"the",
"_call... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/heap/heap_base.py#L88-L97 | train |
angr/angr | angr/state_plugins/heap/heap_base.py | SimHeapBase._realloc | def _realloc(self, ptr, size):
"""
Handler for any libc `realloc` SimProcedure call. If the heap has faithful support for `realloc`, it ought to be
implemented in a `realloc` function (as opposed to the `_realloc` function).
:param ptr: the location in memory to be reallocated
:... | python | def _realloc(self, ptr, size):
"""
Handler for any libc `realloc` SimProcedure call. If the heap has faithful support for `realloc`, it ought to be
implemented in a `realloc` function (as opposed to the `_realloc` function).
:param ptr: the location in memory to be reallocated
:... | [
"def",
"_realloc",
"(",
"self",
",",
"ptr",
",",
"size",
")",
":",
"raise",
"NotImplementedError",
"(",
"\"%s not implemented for %s\"",
"%",
"(",
"self",
".",
"_realloc",
".",
"__func__",
".",
"__name__",
",",
"self",
".",
"__class__",
".",
"__name__",
")",... | Handler for any libc `realloc` SimProcedure call. If the heap has faithful support for `realloc`, it ought to be
implemented in a `realloc` function (as opposed to the `_realloc` function).
:param ptr: the location in memory to be reallocated
:param size: the new size desired for the allocation | [
"Handler",
"for",
"any",
"libc",
"realloc",
"SimProcedure",
"call",
".",
"If",
"the",
"heap",
"has",
"faithful",
"support",
"for",
"realloc",
"it",
"ought",
"to",
"be",
"implemented",
"in",
"a",
"realloc",
"function",
"(",
"as",
"opposed",
"to",
"the",
"_r... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_plugins/heap/heap_base.py#L99-L108 | train |
angr/angr | angr/analyses/boyscout.py | BoyScout._reconnoiter | def _reconnoiter(self):
"""
The implementation here is simple - just perform a pattern matching of all different architectures we support,
and then perform a vote.
"""
# Retrieve the binary string of main binary
votes = defaultdict(int)
for arch in all_arches:
... | python | def _reconnoiter(self):
"""
The implementation here is simple - just perform a pattern matching of all different architectures we support,
and then perform a vote.
"""
# Retrieve the binary string of main binary
votes = defaultdict(int)
for arch in all_arches:
... | [
"def",
"_reconnoiter",
"(",
"self",
")",
":",
"# Retrieve the binary string of main binary",
"votes",
"=",
"defaultdict",
"(",
"int",
")",
"for",
"arch",
"in",
"all_arches",
":",
"regexes",
"=",
"set",
"(",
")",
"if",
"not",
"arch",
".",
"function_prologs",
":... | The implementation here is simple - just perform a pattern matching of all different architectures we support,
and then perform a vote. | [
"The",
"implementation",
"here",
"is",
"simple",
"-",
"just",
"perform",
"a",
"pattern",
"matching",
"of",
"all",
"different",
"architectures",
"we",
"support",
"and",
"then",
"perform",
"a",
"vote",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/boyscout.py#L22-L63 | train |
angr/angr | angr/analyses/variable_recovery/variable_recovery_base.py | parse_stack_pointer | def parse_stack_pointer(sp):
"""
Convert multiple supported forms of stack pointer representations into stack offsets.
:param sp: A stack pointer representation.
:return: A stack pointer offset.
:rtype: int
"""
if isinstance(sp, int):
return sp
if isinstance(sp, StackBa... | python | def parse_stack_pointer(sp):
"""
Convert multiple supported forms of stack pointer representations into stack offsets.
:param sp: A stack pointer representation.
:return: A stack pointer offset.
:rtype: int
"""
if isinstance(sp, int):
return sp
if isinstance(sp, StackBa... | [
"def",
"parse_stack_pointer",
"(",
"sp",
")",
":",
"if",
"isinstance",
"(",
"sp",
",",
"int",
")",
":",
"return",
"sp",
"if",
"isinstance",
"(",
"sp",
",",
"StackBaseOffset",
")",
":",
"return",
"sp",
".",
"offset",
"if",
"isinstance",
"(",
"sp",
",",
... | Convert multiple supported forms of stack pointer representations into stack offsets.
:param sp: A stack pointer representation.
:return: A stack pointer offset.
:rtype: int | [
"Convert",
"multiple",
"supported",
"forms",
"of",
"stack",
"pointer",
"representations",
"into",
"stack",
"offsets",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/variable_recovery/variable_recovery_base.py#L14-L37 | train |
angr/angr | angr/analyses/variable_recovery/variable_recovery_base.py | VariableRecoveryBase.get_variable_definitions | def get_variable_definitions(self, block_addr):
"""
Get variables that are defined at the specified block.
:param int block_addr: Address of the block.
:return: A set of variables.
"""
if block_addr in self._outstates:
return self._outstates[... | python | def get_variable_definitions(self, block_addr):
"""
Get variables that are defined at the specified block.
:param int block_addr: Address of the block.
:return: A set of variables.
"""
if block_addr in self._outstates:
return self._outstates[... | [
"def",
"get_variable_definitions",
"(",
"self",
",",
"block_addr",
")",
":",
"if",
"block_addr",
"in",
"self",
".",
"_outstates",
":",
"return",
"self",
".",
"_outstates",
"[",
"block_addr",
"]",
".",
"variables",
"return",
"set",
"(",
")"
] | Get variables that are defined at the specified block.
:param int block_addr: Address of the block.
:return: A set of variables. | [
"Get",
"variables",
"that",
"are",
"defined",
"at",
"the",
"specified",
"block",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/variable_recovery/variable_recovery_base.py#L60-L70 | train |
angr/angr | angr/analyses/variable_recovery/variable_recovery_base.py | VariableRecoveryStateBase._phi_node_contains | def _phi_node_contains(self, phi_variable, variable):
"""
Checks if `phi_variable` is a phi variable, and if it contains `variable` as a sub-variable.
:param phi_variable:
:param variable:
:return:
"""
if self.variable_manager[self.function.addr].is_phi_variable... | python | def _phi_node_contains(self, phi_variable, variable):
"""
Checks if `phi_variable` is a phi variable, and if it contains `variable` as a sub-variable.
:param phi_variable:
:param variable:
:return:
"""
if self.variable_manager[self.function.addr].is_phi_variable... | [
"def",
"_phi_node_contains",
"(",
"self",
",",
"phi_variable",
",",
"variable",
")",
":",
"if",
"self",
".",
"variable_manager",
"[",
"self",
".",
"function",
".",
"addr",
"]",
".",
"is_phi_variable",
"(",
"phi_variable",
")",
":",
"return",
"variable",
"in"... | Checks if `phi_variable` is a phi variable, and if it contains `variable` as a sub-variable.
:param phi_variable:
:param variable:
:return: | [
"Checks",
"if",
"phi_variable",
"is",
"a",
"phi",
"variable",
"and",
"if",
"it",
"contains",
"variable",
"as",
"a",
"sub",
"-",
"variable",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/variable_recovery/variable_recovery_base.py#L185-L196 | train |
angr/angr | angr/state_hierarchy.py | StateHierarchy.lineage | def lineage(self, h):
"""
Returns the lineage of histories leading up to `h`.
"""
lineage = [ ]
predecessors = list(self._graph.predecessors(h))
while len(predecessors):
lineage.append(predecessors[0])
predecessors = list(self._graph.predecessors... | python | def lineage(self, h):
"""
Returns the lineage of histories leading up to `h`.
"""
lineage = [ ]
predecessors = list(self._graph.predecessors(h))
while len(predecessors):
lineage.append(predecessors[0])
predecessors = list(self._graph.predecessors... | [
"def",
"lineage",
"(",
"self",
",",
"h",
")",
":",
"lineage",
"=",
"[",
"]",
"predecessors",
"=",
"list",
"(",
"self",
".",
"_graph",
".",
"predecessors",
"(",
"h",
")",
")",
"while",
"len",
"(",
"predecessors",
")",
":",
"lineage",
".",
"append",
... | Returns the lineage of histories leading up to `h`. | [
"Returns",
"the",
"lineage",
"of",
"histories",
"leading",
"up",
"to",
"h",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_hierarchy.py#L108-L121 | train |
angr/angr | angr/state_hierarchy.py | StateHierarchy.most_mergeable | def most_mergeable(self, states):
"""
Find the "most mergeable" set of states from those provided.
:param states: a list of states
:returns: a tuple of: (a list of states to merge, those states' common history, a list of states to not merge yet)
"""
histories = set(self... | python | def most_mergeable(self, states):
"""
Find the "most mergeable" set of states from those provided.
:param states: a list of states
:returns: a tuple of: (a list of states to merge, those states' common history, a list of states to not merge yet)
"""
histories = set(self... | [
"def",
"most_mergeable",
"(",
"self",
",",
"states",
")",
":",
"histories",
"=",
"set",
"(",
"self",
".",
"get_ref",
"(",
"s",
".",
"history",
")",
"for",
"s",
"in",
"states",
")",
"for",
"n",
"in",
"networkx",
".",
"algorithms",
".",
"dfs_postorder_no... | Find the "most mergeable" set of states from those provided.
:param states: a list of states
:returns: a tuple of: (a list of states to merge, those states' common history, a list of states to not merge yet) | [
"Find",
"the",
"most",
"mergeable",
"set",
"of",
"states",
"from",
"those",
"provided",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/state_hierarchy.py#L198-L218 | train |
angr/angr | angr/engines/engine.py | SimEngine.process | def process(self, state, *args, **kwargs):
"""
Perform execution with a state.
You should only override this method in a subclass in order to provide the correct method signature and
docstring. You should override the ``_process`` method to do your actual execution.
:param stat... | python | def process(self, state, *args, **kwargs):
"""
Perform execution with a state.
You should only override this method in a subclass in order to provide the correct method signature and
docstring. You should override the ``_process`` method to do your actual execution.
:param stat... | [
"def",
"process",
"(",
"self",
",",
"state",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"inline",
"=",
"kwargs",
".",
"pop",
"(",
"'inline'",
",",
"False",
")",
"force_addr",
"=",
"kwargs",
".",
"pop",
"(",
"'force_addr'",
",",
"None",
")... | Perform execution with a state.
You should only override this method in a subclass in order to provide the correct method signature and
docstring. You should override the ``_process`` method to do your actual execution.
:param state: The state with which to execute. This state will be co... | [
"Perform",
"execution",
"with",
"a",
"state",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/engines/engine.py#L17-L84 | train |
angr/angr | angr/engines/engine.py | SimEngine.check | def check(self, state, *args, **kwargs):
"""
Check if this engine can be used for execution on the current state. A callback `check_failure` is called upon
failed checks. Note that the execution can still fail even if check() returns True.
You should only override this method in a subcl... | python | def check(self, state, *args, **kwargs):
"""
Check if this engine can be used for execution on the current state. A callback `check_failure` is called upon
failed checks. Note that the execution can still fail even if check() returns True.
You should only override this method in a subcl... | [
"def",
"check",
"(",
"self",
",",
"state",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"self",
".",
"_check",
"(",
"state",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] | Check if this engine can be used for execution on the current state. A callback `check_failure` is called upon
failed checks. Note that the execution can still fail even if check() returns True.
You should only override this method in a subclass in order to provide the correct method signature and
... | [
"Check",
"if",
"this",
"engine",
"can",
"be",
"used",
"for",
"execution",
"on",
"the",
"current",
"state",
".",
"A",
"callback",
"check_failure",
"is",
"called",
"upon",
"failed",
"checks",
".",
"Note",
"that",
"the",
"execution",
"can",
"still",
"fail",
"... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/engines/engine.py#L86-L100 | train |
angr/angr | angr/analyses/cfg/indirect_jump_resolvers/resolver.py | IndirectJumpResolver._is_target_valid | def _is_target_valid(self, cfg, target): # pylint:disable=no-self-use
"""
Check if the resolved target is valid.
:param cfg: The CFG analysis object.
:param int target: The target to check.
:return: True if the target is valid. False otherwise.
:rtyp... | python | def _is_target_valid(self, cfg, target): # pylint:disable=no-self-use
"""
Check if the resolved target is valid.
:param cfg: The CFG analysis object.
:param int target: The target to check.
:return: True if the target is valid. False otherwise.
:rtyp... | [
"def",
"_is_target_valid",
"(",
"self",
",",
"cfg",
",",
"target",
")",
":",
"# pylint:disable=no-self-use",
"if",
"self",
".",
"base_state",
"is",
"not",
"None",
":",
"try",
":",
"if",
"self",
".",
"base_state",
".",
"solver",
".",
"is_true",
"(",
"(",
... | Check if the resolved target is valid.
:param cfg: The CFG analysis object.
:param int target: The target to check.
:return: True if the target is valid. False otherwise.
:rtype: bool | [
"Check",
"if",
"the",
"resolved",
"target",
"is",
"valid",
"."
] | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/analyses/cfg/indirect_jump_resolvers/resolver.py#L44-L68 | train |
angr/angr | angr/engines/unicorn.py | SimEngineUnicorn.process | def process(self, state,
step=None,
extra_stop_points=None,
inline=False,
force_addr=None,
**kwargs):
"""
:param state: The state with which to execute
:param step: How many basic blocks we want to execute
... | python | def process(self, state,
step=None,
extra_stop_points=None,
inline=False,
force_addr=None,
**kwargs):
"""
:param state: The state with which to execute
:param step: How many basic blocks we want to execute
... | [
"def",
"process",
"(",
"self",
",",
"state",
",",
"step",
"=",
"None",
",",
"extra_stop_points",
"=",
"None",
",",
"inline",
"=",
"False",
",",
"force_addr",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"super",
"(",
"SimEngineUnicorn",
",... | :param state: The state with which to execute
:param step: How many basic blocks we want to execute
:param extra_stop_points: A collection of addresses at which execution should halt
:param inline: This is an inline execution. Do not bother copying the... | [
":",
"param",
"state",
":",
"The",
"state",
"with",
"which",
"to",
"execute",
":",
"param",
"step",
":",
"How",
"many",
"basic",
"blocks",
"we",
"want",
"to",
"execute",
":",
"param",
"extra_stop_points",
":",
"A",
"collection",
"of",
"addresses",
"at",
... | 4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40 | https://github.com/angr/angr/blob/4e2f97d56af5419ee73bdb30482c8dd8ff5f3e40/angr/engines/unicorn.py#L19-L39 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.