ida_get_function_decompiled_by_address

Retrieve decompiled pseudocode for a specific function using its memory address in IDA Pro. This tool helps analyze binary code by converting machine instructions into readable pseudocode.

Instructions

Get decompiled pseudocode for a function by address

Input Schema

TableJSON Schema

Name	Required	Description	Default
`address`	Yes

Implementation Reference

plugin/ida_mcp_server_plugin/ida_mcp_core.py:201-239 (handler)

Core IDA plugin implementation: performs Hex-Rays decompilation of the function at the given address and returns pseudocode as string.

def _get_function_decompiled_by_address_internal(self, address: int) -> Dict[str, Any]:
    """Internal implementation for get_function_decompiled_by_address without sync wrapper"""
    try:
        # Get function from address
        func = idaapi.get_func(address)
        if not func:
            return {"error": f"No function found at address 0x{address:X}"}
        
        # Get function name
        func_name = idaapi.get_func_name(func.start_ea)
        
        # Try to import decompiler module
        try:
            import ida_hexrays
        except ImportError:
            return {"error": "Hex-Rays decompiler is not available"}
        
        # Check if decompiler is available
        if not ida_hexrays.init_hexrays_plugin():
            return {"error": "Unable to initialize Hex-Rays decompiler"}
        
        # Get decompiled function
        cfunc = None
        try:
            cfunc = ida_hexrays.decompile(func.start_ea)
        except Exception as e:
            return {"error": f"Unable to decompile function: {str(e)}"}
        
        if not cfunc:
            return {"error": "Decompilation failed"}
        
        # Get pseudocode as string
        decompiled_code = str(cfunc)
        
        return {"decompiled_code": decompiled_code, "function_name": func_name}
    except Exception as e:
        traceback.print_exc()
        return {"error": str(e)}

src/mcp_server_ida/server.py:858-893 (handler)

MCP server-side handler: proxies the tool call by sending socket request to IDA plugin and formats the response.

def get_function_decompiled_by_address(self, address: str) -> str:
    """Get decompiled pseudocode for a function by its address"""
    try:
        # Convert string address to int
        try:
            addr_int = int(address, 16) if address.startswith("0x") else int(address)
        except ValueError:
            return f"Error: Invalid address format '{address}', expected hexadecimal (0x...) or decimal"
            
        response: Dict[str, Any] = self.communicator.send_request(
            "get_function_decompiled_by_address", 
            {"address": addr_int}
        )
        
        if "error" in response:
            return f"Error retrieving decompiled code for address '{address}': {response['error']}"
        
        decompiled_code: Any = response.get("decompiled_code")
        function_name: str = response.get("function_name", "Unknown function")
        
        # Detailed type checking and conversion
        if decompiled_code is None:
            return f"Error: No decompiled code returned for address '{address}'"
            
        # Ensure result is string
        if not isinstance(decompiled_code, str):
            self.logger.warning(f"Decompiled code type is not string but {type(decompiled_code).__name__}, attempting conversion")
            try:
                decompiled_code = str(decompiled_code)
            except Exception as e:
                return f"Error: Failed to convert decompiled code: {str(e)}"
        
        return f"Decompiled code for function '{function_name}' at address {address}:\n{decompiled_code}"
    except Exception as e:
        self.logger.error(f"Error getting function decompiled code by address: {str(e)}", exc_info=True)
        return f"Error retrieving decompiled code for address '{address}': {str(e)}"

src/mcp_server_ida/server.py:933-937 (registration)

MCP tool registration in server.list_tools(): defines tool name, description, and input schema.

Tool(
    name=IDATools.GET_FUNCTION_DECOMPILED_BY_ADDRESS,
    description="Get decompiled pseudocode for a function by address",
    inputSchema=GetFunctionDecompiledByAddress.schema(),
),

src/mcp_server_ida/server.py:27-28 (schema)
Pydantic model defining the input schema: expects 'address' as string.
```
class GetFunctionDecompiledByAddress(BaseModel):
    address: str  # Hexadecimal address as string
```
src/mcp_server_ida/server.py:91-91 (registration)
Enum constant defining the exact tool name string used for registration and dispatching.
```
GET_FUNCTION_DECOMPILED_BY_ADDRESS = "ida_get_function_decompiled_by_address"
```

plugin/ida_mcp_server_plugin.py:191-192 (handler)

IDA plugin socket request handler: dispatches 'get_function_decompiled_by_address' request to IDAMCPCore.

elif request_type == "get_function_decompiled_by_address":
    response.update(self.core.get_function_decompiled_by_address(request_data.get("address", 0)))

ida-mcp-server