[Date Prev][Date Next][Thread Prev][Thread Next]
- Subject: Low-level access to the innards
- From: Eduardo Ochs <eduardoochs@...>
- Date: Sat, 5 Jan 2013 22:01:52 -0200
I have a handful of (related) questions that I've been postponing
asking at the list for months, or maybe years - because I was
afraid that the main answers were going to be "why do you want
this?" and "what you want is wrong".
The real "why" would take pages - and probably also a couple of
videos to show how, in certain very specific contexts, it does
make sense to send some very long commands to GDB - commands that
would then be _readable_ by low-level-minded humans, but that
would not be _written_ by hand (often). So let me leave
these "why"s to be answered later - I am preparing one of the
said videos, by the way -, and let me try to disguise a few of my
questions as challenges to people who know Lua's innards quite
well. Here they are.
Suppose that we've set a breakpoint in math_sin, and then we ran
this Lua code:
outer_fun = function (a, b)
local c, d, e = "CC", "DD", "EE"
return 1 + inner_fun("FF", "GG")
inner_fun = function (f, g)
local h, i, j = "HH", "II", "JJ"
twentytwo = "22"
twentytwon = 22
So now we are at the GDB prompt, in math_sin, i.e., in
and thus we have access to a variable L ("lua_State *L"), and we
know that GDB can call functions and has _some_ support for C
macros, but it feels happier when it just has to deal with
low-level expressions like:
So, it _must_ be possible to start from just L - plus the hash
values for the strings "twentytwo", "twentytwon", "a", "b",
..., "j" - and then, through a contorted series of array and
field accesses, reach the positions in the memory where are
1) the value of the variable "twentytwo" (as a string),
2) the value of the variable "twentytwon" (as a number),
3) the name of the variable "twentytwo" (as a string),
4) the value of the parameter "g" of inner_fun,
5) the name - "g" - of the second parameter of inner_fun,
6) the value of the local variable "e" of outer_fun,
7) the name of the local variable "e" of outer_fun.
Think that your expressions will be used to explain the data
structures of Lua - more precisely, "PUC-Lua" - in _just_ the
sample case above - the reader is expected to be able to
generalize by himself. So: start from L, and use
just "->"s, "."s, "*"s, and "[n]"s with explicit "n"s. Don't be
afraid to use magic numbers in the "[n]"s - though explanations
like "we can calculate that n by using the function call
such-and-such" are welcome...
Note that such low-level answers are far from useless - they are
"canonical" in a precise sense (that I am not going to formalize
now =)), and they are very easy to _test_ and to _annotate_ -
e.g., "this sequence of four field accesses here correspond to
the effect of macro `blah', these others here to the function
call `bletch'" - and they can sort of complement texts like: