Use cases for symbol tables in Lua land?

[MBDesu]

Hello! I have been working with the Lua API quite a bit, and there are a few things that seemingly don't work as I might expect them to, symbol tables being the latest among them.

I assumed that symbol tables would allow access to the debugger's symbol tables (and, rather excitingly, allow for adding symbols to the debugger's tables) for use in debugger expressions, but this does not seem the case, which leaves me to wonder: what is the point of symbol tables?

Expectation was something like this allowing me to print a stack trace from Lua land on breakpoint (in a m68k architecture machine, namely CPS2):

local syms = emu.symbol_table(manager.machine.devices[':maincpu'])
local m = manager.machine.devices[':maincpu'].spaces['program']

syms:add(
  'print_stack_trace',
  1,
  1,
  function(usp)
    local current_address = usp
    local stack_value = m:read_u32(usp)
    while stack_value ~= 0 do
      print(string.format('%08x', stack_value))
      current_address = current_address + 8
      stack_value = m:read_u32(current_address)
    end
  end
)

local expr = emu.parsed_expression(syms, 'print_stack_trace(usp)')

emu.add_machine_stop_notifier(function()
  expr:execute()
end)

Firstly, emu.add_machine_stop_notifier() does not fire on breakpoint. Okay, fair enough, but emu.parsed_expression() also throws an error, as usp is not a symbol in the symbol table, as the debugger symbol table and this created one are two different things.

Still, I thought maybe I'd be able to do something like this in the debugger: bpset 123456,1,{ print_stack_trace(usp); g }, but alas, as above, the symbol is not created in the debugger, and thus does not exist there.

Now, you can print a stack trace using symbols; that's certainly achievable. But you end up doing all of the things you'd be able to do without symbol tables anyway:

local cpu = manager.machine.devices[':maincpu']
local m = cpu.spaces['program']

syms:add(
  'usp',
  function()
    return cpu.state['USP'].value
  end,
  function(addr)
    cpu.state['USP'].value = addr
  end,
  '%08x')

syms:add('print_stack_trace', 1, 1, function(usp)
  local current_address = usp
  local stack_value = m:read_u32(current_address)
  while stack_value ~= 0 do
    print(string.format('%08x', stack_value))
    current_address = current_address + 8
    stack_value = m:read_u32(current_address)
  end
end)

emu.parsed_expression(syms, 'print_stack_trace(usp)'):execute()

This all leaves me scratching my head and wondering: what is the point of symbol tables?

The only use case I can think of is easily sharing functions and data between plugins, but beyond that, I'm not smart enough to come up with anything.

What is their "intended" use?

[cuavas]

This all leaves me scratching my head and wondering: what is the point of symbol tables?

Lua plugins need to be able to manipulate symbol tables in order for me to be able create a proper replacement for the built-in cheat engine. The current hacky approach of trying to lexically convert debugger expressions to Lua expressions is flaky and doesn’t always work properly. More generally, symbol tables can be by plugins or scripts that accept user input using debugger expression syntax to trigger on arbitrary events.

Your observation that they don’t allow scripts to inject symbols into the debugger is correct. That may change in the future.

emu.add_machine_stop_notifier() adds a notifier that will be called at stop time, i.e. when the emulation session ends (either exiting MAME, or returning to the system selection menu). Plugins usually use this to release resources, save settings, etc. In particular, textures need to be explicitly released at this time. Halting for the debugger is not the same thing at all. Also, you need to actually save the subscription returned by add_machine_stop_notifier or you’ll be unsubscribed when it’s garbage collected.

[MBDesu]

Your observation that they don’t allow scripts to inject symbols into the debugger is correct. That may change in the future.

I just got a build environment set up to try to investigate this myself, as this would be an incredibly useful feature for many problems I'm trying to solve.

emu.add_machine_stop_notifier() adds a notifier that will be called at stop time, i.e. when the emulation session ends (either exiting MAME, or returning to the system selection menu). Plugins usually use this to release resources, save settings, etc. In particular, textures need to be explicitly released at this time.

I'm VMP_MBD on Reddit btw, and we've spoken at length about textures. I certainly do release them at stop, but...

Also, you need to actually save the subscription returned by add_machine_stop_notifier or you’ll be unsubscribed when it’s garbage collected.

I haven't been doing this, so I suppose it probably never actually happens. I sometimes forget that Lua is a garbage collected language.

Halting for the debugger is not the same thing at all.

Is there any way to halt for the debugger and execute some callback?

I think we might've spoken about this once and you had mentioned that when the debugger is not running, execution is optimized in some way that makes this difficult, but I don't know if I'm recalling the exact context.