S4A debugging with avr-gdb and simavr


While this has been possible for a while in S4A, with long workarounds, it got a lot easier in the 5.0 beta IDE.

Using the "open folder" project structure, save work into a folder and build, the "Terminal" button enables. Press it and you're in a terminal session within the folder, with a command line build ready to go. Run "make simulate-gdb" and you have the program running on simavr, with the debug port open for avr-gdb to attach to. Create a separate Terminal window with the same button for your avr-gdb session and run "avr-gdb main.elf" to pick up the image symbols. In the session choose "target remote :1234" and you're in! My preferred run mode for avr-gdb is "layout asm" or "layout reg" (seen here). Obviously it's not for a beginner, but for an experienced gdb jockey it should prove interesting.


Hints

You can find these on other blogs about gdb and simavr. But might be useful here.

To dump memory...
***

(https://sourceware.org/gdb/onlinedocs/gdb/Memory.html)

x/30xb 0x200

...will show 3 bytes in hexadecimal starting at 0x200 but there's a gotcha... gdb usually only expects one memory space, in this case you'll see the contents of "flash" memory (or its simulated equivalent). Simavr has a workaround. RAM (which is what you will usually want to inspect) "starts" at 0x800000!

For example...

(gdb) x/30xb 0x800000

0x800000:       0xd2    0x00    0x00    0x00    0x00    0x00    0x00    0x00
0x800008:       0x00    0x00    0x00    0x00    0x22    0x00    0x22    0x00
0x800010:       0x00    0x00    0x22    0x00    0x1a    0x02    0x18    0x02
0x800018:       0x18    0x02    0x00    0x00    0x47    0x00
...dumping registers shows that is correct...
info reg
r0             0xd2                210
r1             0x0                 0
r2             0x0                 0
r3             0x0                 0
r4             0x0                 0
r5             0x0                 0
r6             0x0                 0
r7             0x0                 0
r8             0x0                 0
r9             0x0                 0
r10            0x0                 0
r11            0x0                 0
r12            0x22                34
r13            0x0                 0
r14            0x22                34
r15            0x0                 0
r16            0x0                 0
r17            0x0                 0
r18            0x22                34
r19            0x0                 0
r20            0x1a                26
r21            0x2                 2
r22            0x18                24
r23            0x2                 2
r24            0x18                24
r25            0x2                 2
r26            0x0                 0
r27            0x0                 0
r28            0x47                71
r29            0x0                 0
r30            0x18                24
r31            0x2                 2
SREG           0x80                128
SP             0x8f7               0x8008f7
PC2            0x148               328
pc             0xa4                0x148 <main+98>

(remember the first 32 bytes of RAM on AVR map to the 32 registers r0-r31)

To control TUI...
***
You can find this easily in Google but posted here to save a search: (https://sourceware.org/gdb/onlinedocs/gdb/TUI-Keys.html)
Handy keys:
C-x a  ... leave TUI
C-x o  ... move to next window (so you can scroll code or commands)
C-L ... reload the screen if it gets garbled

Comments

Post a Comment

Popular posts from this blog

Halloween LED lights on a plastic trick or treat cauldron

Image
Halloween has past but it wasn’t uneventful. My two year old daughter went trick or treating for the first time and it was all so exciting! When i saw the plastic cauldron she was carrying as a trick or treat bag i had an idea. I could use an arduino to operate red LEDs and make the cauldron flash on and off like little evil eyes. I knew she would love it! Once I drilled the holes and got all the pieces I needed: 2 red LEDs soldered in series with a resistor. I connected those to a breadboard arduino I had spare. (See my blog post on making a breadboard arduino.) You can just use a normal Arduino UNO here instead if you prefer. My reasons are because they're cheaper, and also because a breadboard Arduino uses less power and I wanted this to be battery powered. I'm powering the whole thing with 3 AA batteries in a battery case. Because Maplin has shut down in the UK :((( I will have to wait for the battery holder to be delivered... no more weekend fun popping down t
Read more

All about bootloaders

 BOOTLOADERS *** Some interesting general boot loader facts: The Boot Loader is basically a section at the top of flash memory, how big it is depends on the BOOTSZ1 and BOOTSZ0 bits in the Low Fuse byte. It has the special property that ONLY while the core is running instructions in the bootloader, a special instruction called SPM will function. This function allows writing data to the flash memory. As normal with all flash, you need to erase the page you are writing first, otherwise your write operation will often not function correctly. I think you can change 1 bits to 0 bits but not the other way around, which is true for all flash writing. So the flash erase process always sets a flash memory page to all 0xFF (all 1 bits) The usual way the boot loader runs is if the fuse bit BOOTRST is active (i.e. it reads as a 0!) then when the MCU is reset, it will start execution at the beginning of the bootloader (as defined above). If the bit is not set, it will start execution at 0x0000. But
Read more

code signing, entitlements, bundles, sandboxes, hardened runtime, notarisation, app store security

Some people had mentioned troubles with code signing, i thought a brain dump of my learnings on it might be informative and helpful as I've learned a lot in developing a mac app (the s4a IDE).  Some of these concepts are used in ios too but this post is about mac apps. First up, terminology. Code signing. *** This is a variant of normal PKI (public key infrastructure) signing. A hash is made of the binary you're signing (the actual macho executable file), then encrypted with your private key to make a signature that anyone with your public key can decrypt and verify to check your binary hasn't been altered in any way since you signed it. Code signing could in theory be done with any tool, (many of these concepts are NOT mac/ios only concepts but follow general unix/windows/etc. principles and ideas widely used across industry), but in reality, people on a mac use the built in (to macOS) tool "codesign" which is a command line tool that can create, alter, remove an
Read more