gdb_info_registers

Instructions

Implementation Reference

• src/index.ts:1112-1154 (handler)

  Handler function that processes the gdb_info_registers tool call. Extracts sessionId and optional register, validates session, executes the GDB 'info registers' command (with optional register), and returns formatted output or error.

  private async handleGdbInfoRegisters(args: any) {
    const { sessionId, register } = args;
    
    if (!activeSessions.has(sessionId)) {
      return {
        content: [
          {
            type: 'text',
            text: `No active GDB session with ID: ${sessionId}`
          }
        ],
        isError: true
      };
    }
    
    const session = activeSessions.get(sessionId)!;
    
    try {
      // Build info registers command, optionally with specific register
      const command = register ? `info registers ${register}` : `info registers`;
      const output = await this.executeGdbCommand(session, command);
      
      return {
        content: [
          {
            type: 'text',
            text: `Register info${register ? ` for ${register}` : ''}:\n\n${output}`
          }
        ]
      };
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      return {
        content: [
          {
            type: 'text',
            text: `Failed to get register info: ${errorMessage}`
          }
        ],
        isError: true
      };
    }
  }

• src/index.ts:338-351 (schema)

  Input schema defining the parameters for the gdb_info_registers tool: required sessionId (string) and optional register (string).

  inputSchema: {
    type: 'object',
    properties: {
      sessionId: {
        type: 'string',
        description: 'GDB session ID'
      },
      register: {
        type: 'string',
        description: 'Specific register to display (optional)'
      }
    },
    required: ['sessionId']
  }

• src/index.ts:335-352 (registration)

  Tool registration in the list returned by ListToolsRequestSchema, specifying name, description, and input schema.

  {
    name: 'gdb_info_registers',
    description: 'Display registers',
    inputSchema: {
      type: 'object',
      properties: {
        sessionId: {
          type: 'string',
          description: 'GDB session ID'
        },
        register: {
          type: 'string',
          description: 'Specific register to display (optional)'
        }
      },
      required: ['sessionId']
    }
  }

• src/index.ts:389-390 (registration)

  Switch case in CallToolRequestSchema handler that routes calls to the gdb_info_registers handler function.

  case 'gdb_info_registers':
    return await this.handleGdbInfoRegisters(request.params.arguments);

• src/index.ts:1159-1217 (helper)

  Helper function used by the handler to execute arbitrary GDB commands via stdin/stdout, waiting for response completion with timeout and error handling.

  private executeGdbCommand(session: GdbSession, command: string): Promise<string> {
    return new Promise<string>((resolve, reject) => {
      if (!session.ready) {
        reject(new Error('GDB session is not ready'));
        return;
      }
      
      // Write command to GDB's stdin
      if (session.process.stdin) {
        session.process.stdin.write(command + '\n');
      } else {
        reject(new Error('GDB stdin is not available'));
        return;
      }
      
      let output = '';
      let responseComplete = false;
      
      // Create a one-time event handler for GDB output
      const onLine = (line: string) => {
        output += line + '\n';
        
        // Check if this line indicates the end of the GDB response
        if (line.includes('(gdb)') || line.includes('^done') || line.includes('^error')) {
          responseComplete = true;
          
          // If we've received the complete response, resolve the promise
          if (responseComplete) {
            // Remove the listener to avoid memory leaks
            session.rl.removeListener('line', onLine);
            resolve(output);
          }
        }
      };
      
      // Add the line handler to the readline interface
      session.rl.on('line', onLine);
      
      // Set a timeout to prevent hanging
      const timeout = setTimeout(() => {
        session.rl.removeListener('line', onLine);
        reject(new Error('GDB command timed out'));
      }, 10000); // 10 second timeout
      
      // Handle GDB errors
      const errorHandler = (data: Buffer) => {
        const errorText = data.toString();
        output += `[stderr] ${errorText}\n`;
      };
      
      // Add error handler
      if (session.process.stderr) {
        session.process.stderr.once('data', errorHandler);
      }
      
      // Clean up event handlers when the timeout expires
      timeout.unref();
    });
  }