Functions Plugin

class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping[K, Function]):
    """Manages functions with optional LRU caching and LMDB spilling."""

# Unlimited functions in memory
fm = FunctionManager(kb)

# Limit to 1000 functions in memory
fm = FunctionManager(kb, cache_limit=1000)

# Access by address
func = kb.functions[0x401000]

# Access by name
func = kb.functions['main']

# Check if function exists
if 0x401000 in kb.functions:
    print("Function exists")

# Get number of functions
num_funcs = len(kb.functions)

# Iterate over all functions
for addr in kb.functions:
    func = kb.functions[addr]
    print(f"{hex(addr)}: {func.name}")

# Iterate over address, function pairs
for addr, func in kb.functions.items():
    print(f"{hex(addr)}: {func.name}")

kb.functions.function(
    addr: int | None = None,
    name: str | None = None,
    check_previous_names: bool = False,
    create: bool = False,
    syscall: bool = False,
    plt: bool | None = None
) -> Function | None

# Get function by address
func = kb.functions.function(addr=0x401000)

# Get or create function
func = kb.functions.function(addr=0x401000, create=True)

# Get function by name
main = kb.functions.function(name='main')

# Filter PLT functions
plt_func = kb.functions.function(addr=0x401000, plt=True)

kb.functions.get_by_addr(addr: int, meta_only: bool = False) -> Function

kb.functions.get_by_name(
    name: str,
    check_previous_names: bool = False
) -> Generator[Function]

# Get all functions named 'helper'
for func in kb.functions.get_by_name('helper'):
    print(f"Found helper at {hex(func.addr)}")

# Include previous names in search
for func in kb.functions.get_by_name('old_name', check_previous_names=True):
    print(f"Function was previously named 'old_name': {func.name}")

kb.functions.get_addrs_by_name(
    name: str,
    check_previous_names: bool = False
) -> set[int]

kb.functions.contains_addr(addr: int) -> bool

kb.functions.query(query: str, check_previous_names: bool = False) -> Function | None

# Query by name in main object
func = kb.functions.query('::main')

# Query by address and name
func = kb.functions.query('::0x401000::main')

# Query by object and name
func = kb.functions.query('::libc.so::malloc')

kb.functions.floor_addr(addr: int) -> int | None
kb.functions.floor_func(addr: int) -> Function | None
kb.functions.ceiling_addr(addr: int) -> int | None
kb.functions.ceiling_func(addr: int) -> Function | None

kb.functions.items(meta_only: bool = False) -> Generator[tuple[int, Function]]

kb.functions.values(meta_only: bool = False) -> Generator[Function]

# Iterate all functions
for func in kb.functions.values():
    print(f"{func.name}: {func.size} bytes")

# Iterate meta-only (faster for large binaries)
for func in kb.functions.values(meta_only=True):
    print(func.name)  # Can access basic properties only

# Create new function
kb.functions[0x401000] = Function(kb.functions, 0x401000, name='my_func')

# Or use function() with create=True
func = kb.functions.function(addr=0x401000, create=True)

# Delete by address
del kb.functions[0x401000]

kb.functions.function_name_changed(
    addr: int,
    old_name: str | None,
    new_name: str
) -> None

import networkx as nx

# Get all callers of a function
callers = list(kb.functions.callgraph.predecessors(0x401000))

# Get all callees
callees = list(kb.functions.callgraph.successors(0x401000))

# Check if function A calls function B
if kb.functions.callgraph.has_edge(0x401000, 0x402000):
    print("Function 0x401000 calls 0x402000")

# Get edge data
for src, dst, data in kb.functions.callgraph.edges(data=True):
    edge_type = data.get('type', 'call')
    print(f"{hex(src)} -> {hex(dst)} ({edge_type})")

if hasattr(kb.functions._function_map, 'cache_limit'):
    fm = kb.functions._function_map
    print(f"Cache limit: {fm.cache_limit}")
    print(f"Cached count: {fm.cached_count}")
    print(f"Spilled count: {fm.spilled_count}")
    print(f"Total count: {fm.total_count}")

fm = kb.functions._function_map

# Load all spilled functions
fm.load_all_spilled()

# Evict all cached functions
fm.evict_all_cached()

# Adjust cache limit
fm.cache_limit = 2000

# Find all non-returning functions
for func in kb.functions.values():
    if func.returning is False:
        print(f"Non-returning: {func.name} at {hex(func.addr)}")

# Find all PLT functions
for addr, func in kb.functions.items():
    if func.is_plt:
        print(f"PLT: {func.name}")

import networkx as nx

# Find leaf functions (no callees)
leaves = [n for n in kb.functions.callgraph.nodes() 
          if kb.functions.callgraph.out_degree(n) == 0]

# Find functions with most callers
callers_count = [(n, kb.functions.callgraph.in_degree(n)) 
                 for n in kb.functions.callgraph.nodes()]
most_called = max(callers_count, key=lambda x: x[1])
print(f"Most called: {hex(most_called[0])} ({most_called[1]} callers)")

# Get call chain between two functions
try:
    path = nx.shortest_path(kb.functions.callgraph, 0x401000, 0x402000)
    print(f"Call path: {' -> '.join(hex(a) for a in path)}")
except nx.NetworkXNoPath:
    print("No call path found")

# Use cache limit for large binaries
kb.functions = FunctionManager(kb, cache_limit=1000)

# Use meta_only for faster iteration
for func in kb.functions.values(meta_only=True):
    # Only access basic properties
    print(f"{hex(func.addr)}: {func.name}")
    # Don't access func.blocks or func.graph (not loaded)