GDB bit position bit-values - c

Question

I'm trying to determine address values and sizes using ARM .elf output in GDB.
With the usual p& and print functions I can determine most of the addresses and and variable sizes, but I can't figure out if the variable is a bitValue or not.
To give an example:
typedef struct
{
bool_t start;
bool_t running :1;
bool_t objectpoolUsable :1;
bool_t ready :1;
bool_t test :1;
bool_t stop :1;
uint8_t defaultMachine;
}bitFieldTest;
bitFieldTest bitValues;
When asking GDB for the address of "bitValues.ready" or "bitValues.running" it will return the same address (since it uses the same address), but doesn't give me the bit position. Neither do I know if it really is a bitvalue or just a boolean taking the space of a uint8_t.
To clarify what I need to do: Give GDB only a single name, what might be a bitValue, and return me the right address and type. If this type is a bitValue, I need to find the bit position. For non-bitValues this works fine, bitValues are causing trouble for now.
Is GDB able to give some kind of output to solve this problem?

Answer 1

There's no way to get this information directly using the gdb expression API. There's no really deep reason for this -- certainly gdb knows the bit position -- but it is a consequence of the fact that gdb expressions mimic the language being debugged, plus just that nobody ever bothered to expose it. Since I've never heard of anyone wanting this before, I think it's safe to say that it is a rare request.
The information is available via gdb's Python API. In particular, if you iterate over the fields of a type, the Field object will have a bitpos member that has the bit offset of the data. Note that the offset is from the start of the enclosing struct.
It would be a relatively simple matter to write a new command in Python that prints this information.

Answer 2

I've solved this problem myself already.
Since I don't know how, and there doesn't seem to be a direct way to return the bit position it can be calculated by asking multiple addresses of GDB.
Using the p& command can determine the address of the variable, but not of its a bitField or the bit-position of it.
By using the print command of GDB on a struct, the location of the bitValue I need, it will return all the available values in this struct, example:
I am looking for the bitField: MachineToUi.tramlining.sensorBoutAdvance
MachineToUi will return the following:
$1 = {speedPls = {present = 0 '\000', time = 0, count = 0, noPulseCount = 0,
value = 0, calDist = 0, calPulses = 0,END DATA ALL DATA: sampleTime = 0}, output = {
trackMarkerL = 0 '\000', trackMarkerR = 0 '\000',
workingLights = 0 '\000', foldingFrame = 0 '\000',
tramlineShutoffL1 = 0 '\000', tramlineShutoffR1 = 0 '\000'}, input = {
fanPpm = 0, workswitch1 = 0 '\000', workswitch2 = 0 '\000',
speedSensor = 0 '\000', fanSensor = 0 '\000', meteringEncL = 0 '\000',
motorEncL = 0 '\000', trackMarkerL = 0 '\000', trackMarkerR = 0 '\000',
lowLvlHopperL = 0 '\000', venturiFlapL = 0 '\000',
calButtonL = 0 '\000'}, hssoOutput = HSSO_IDLE, tramlining = {
active = 0 '\000', restoreCfg = 0 '\000', updateCfg = 0 '\000',
boutAdvance = 0 '\000', boutDecrement = 0 '\000',
noTramlineIncDec = 0 '\000', displaySfks = 0 '\000',
sensorBoutAdvance = 0 '\000', bout = 0 '\000'}, tramlineLeft = 0 '\000',
tramlineRight = 0 '\000', diagOutputs = '\000' <repeats 11 times>,
markerAutoDown = 0 '\000', fanRpm = 0, fanOffTime = 0, speed = 0,
fsAlarmSensorNr = 0 '\000', fsAlarmDisconnectedSensorNr = 0 '\000',
fsAlarmType = 0 '\000', seeding = 0 '\000', actMinSpeed = 0,
actMaxSpeed = 0, lastSensorBout = 0 '\000', ctrMLeftUpFlash = 0 '\000',
ctrMRightUpFlash = 0 '\000', folding = 0 '\000', startLeftOff = 0 '\000',
startRightOff = 0 '\000', halfSideShutOff = 0 '\000',
oldMarkerPosL = 0 '\000', oldMarkerPosR = 0 '\000',
timeDateActive = 0 '\000', licVtCheck = 0 '\000', trialVtCheck = 0 '\000',
trialAlarmActive = 0 '\000', workBeep = 0 '\000', warningBeep = 0 '\000',
errorBeep = 0 '\000', runLed = 0 '\000', tcLicenseOk = 0 '\000',
WDI_start = 0 '\000', newViewSeedCalRecRead = 0 '\000',
MotorStopMarkerDelay = 0}
I'm interested in variable: sensorBoutAdvance.
By listing all the variables around sensorBoutAdvance within a range of at least 8 before the value you want to read and 1 behind the value you want to read, and make GDB return their addresses:
* calButtonL 0x2000435A
* hssoOutput 0x2000435B
* tramlining 0x2000435C
* restoreCfg 0x2000435D
* updateCfg 0x2000435E
* boutAdvance 0x2000435F (Same address! Stop search!)
* boutDecrement
* noTramlineIncDec
* displaySfks
* sensorBoutAdvance (Known address by &p = 0x2000435F)
* bout
* tramlineLeft
* tramlineRight
* diagOutputs
* markerAutoDown
* fanRpm
* fanOffTime
* speed
* fsAlarmSensorNr
* fsAlarmDisconnectedSensorNr
As soon as the same address is found, a bitField is detected. And in this case sensorBoutAdvance can be found on bit 5. If no double address is found, it might not be a bitField, but at least the bit-position won't matter. If the same Address is found right after your the variable you want to read (and not before), your bit position is on the first bit.
It sure requires some parsing, but works for me without having to add external programs or different languages.
Note: This method will only work when all bit-field are only 1-bit long.

Answer 3

import gdb
class Offsets(gdb.Command):
outfile = None
def __init__(self):
super (Offsets, self).__init__ ('offsets-of', gdb.COMMAND_DATA)
def invoke(self, arg, from_tty):
argv = gdb.string_to_argv(arg)
if len(argv) != 2:
raise gdb.GdbError('offsets-of takes exactly 2 arguments.')
self.outfile = open (argv[1], "w")
self.traverse(gdb.lookup_type(argv[0] + '_t').fields(), argv[0], 0)
self.outfile.close()
def traverse(self, branch, fqn, address):
for field in branch:
if field.type.code == gdb.TYPE_CODE_STRUCT:
self.traverse(field.type.fields(), fqn + '.' + field.name, address + field.bitpos//8)
else:
self.outfile.write (('fqn=' + fqn + '.%s offset=%d, size=%d\n' % (field.name, address + field.bitpos//8, field.type.sizeof)))
Offsets()