ida_get_global_variable_by_name

Instructions

Implementation Reference

• plugin/ida_mcp_server_plugin/ida_mcp_core.py:271-295 (handler)

  Main handler method that resolves the global variable name to its address using ida_name.get_name_ea and calls the internal helper to retrieve detailed information. Decorated with @idaread for IDA synchronization.

  def get_global_variable_by_name(self, variable_name: str) -> Dict[str, Any]:
      """Get global variable information by its name"""
      try:
          # Get variable address
          var_addr: int = ida_name.get_name_ea(0, variable_name)
          if var_addr == idaapi.BADADDR:
              return {"error": f"Global variable '{variable_name}' not found"}
          
          # Call internal implementation
          result = self._get_global_variable_by_address_internal(var_addr)
          
          # If successful, add variable name to result
          if "error" not in result and "variable_info" in result:
              # Parse the JSON string back to dict to modify it
              var_info = json.loads(result["variable_info"])
              var_info["name"] = variable_name
              # Convert back to JSON string
              result["variable_info"] = json.dumps(var_info, indent=2)
              
          return result
      except Exception as e:
          print(f"Error getting global variable by name: {str(e)}")
          traceback.print_exc()
          return {"error": str(e)}

• plugin/ida_mcp_server_plugin.py:193-194 (registration)

  Dispatch/registration in the MCP server request handler that maps incoming request_type 'get_global_variable_by_name' to the core handler, extracting 'variable_name' from request data.

  elif request_type == "get_global_variable_by_name":
      response.update(self.core.get_global_variable_by_name(request_data.get("variable_name", "")))

• plugin/ida_mcp_server_plugin/ida_mcp_core.py:301-367 (helper)

  Internal helper implementing the core logic to extract global variable details: name, address, segment info, type via guess_tinfo, size, value (byte/word/etc.), and string value if applicable, using various IDA APIs.

  def _get_global_variable_by_address_internal(self, address: int) -> Dict[str, Any]:
      """Internal implementation for get_global_variable_by_address without sync wrapper"""
      try:
          # Verify address is valid
          if address == idaapi.BADADDR:
              return {"error": f"Invalid address: {hex(address)}"}
          
          # Get variable name if available
          variable_name = ida_name.get_name(address)
          if not variable_name:
              variable_name = f"unnamed_{hex(address)}"
          
          # Get variable segment
          segment: Optional[ida_segment.segment_t] = ida_segment.getseg(address)
          if not segment:
              return {"error": f"No segment found for address {hex(address)}"}
          
          segment_name: str = ida_segment.get_segm_name(segment)
          segment_class: str = ida_segment.get_segm_class(segment)
          
          # Get variable type
          tinfo = idaapi.tinfo_t()
          guess_type: bool = idaapi.guess_tinfo(tinfo, address)
          type_str: str = tinfo.get_type_name() if guess_type else "unknown"
          
          # Try to get variable value
          size: int = ida_bytes.get_item_size(address)
          if size <= 0:
              size = 8  # Default to 8 bytes
          
          # Read data based on size
          value: Optional[int] = None
          if size == 1:
              value = ida_bytes.get_byte(address)
          elif size == 2:
              value = ida_bytes.get_word(address)
          elif size == 4:
              value = ida_bytes.get_dword(address)
          elif size == 8:
              value = ida_bytes.get_qword(address)
          
          # Build variable info
          var_info: Dict[str, Any] = {
              "name": variable_name,
              "address": hex(address),
              "segment": segment_name,
              "segment_class": segment_class,
              "type": type_str,
              "size": size,
              "value": hex(value) if value is not None else "N/A"
          }
          
          # If it's a string, try to read string content
          if ida_bytes.is_strlit(ida_bytes.get_flags(address)):
              str_value = idc.get_strlit_contents(address, -1, 0)
              if str_value:
                  try:
                      var_info["string_value"] = str_value.decode('utf-8', errors='replace')
                  except:
                      var_info["string_value"] = str(str_value)
          
          return {"variable_info": json.dumps(var_info, indent=2)}
      except Exception as e:
          print(f"Error getting global variable by address: {str(e)}")
          traceback.print_exc()
          return {"error": str(e)}

• plugin/ida_mcp_server_plugin.py:216-217 (registration)

  Backward compatibility registration for 'get_global_variable' request_type that also calls the same core handler.

  elif request_type == "get_global_variable":
      response.update(self.core.get_global_variable_by_name(request_data.get("variable_name", "")))