Getting the call stack in C

Is there a way using Norcroft C to access the call stack for debugging purposes? I.e. can I get a list of functions called that have got me to where I am now?

Yes, more details to follow.

Tried to post, but forum formatting has screwed it so will have to try again when I get back.

Thanks, David – appreciate your efforts! ;)

Here’s some code from ARMalyser, which I’m sure I got off someone else.

Link with backtrace.c and registers.s In your main file include signal.h kernel.h, backtrace.h and put in the following code:-

    /* set up signal handler to backtrace on escape */
    signal(SIGINT, Backtrace);

Or you could call the Backtrace function directly, from anywhere. Give an argument of SIGINT to stop, zero to continue.

void Backtrace(int type)
{
#if defined(__riscos) && !defined(NOBACKTRACE)
    {
#ifndef _kernel_registerset
        typedef struct
        {
            int regs [16];
        } _kernel_registerset;
#endif
        _kernel_registerset regset;
        _exception_registers(regset.regs);
        exception_backtrace(stderr, regset.regs);
    }

    fprintf(stderr, "\n");

    if(type==SIGINT)
        exit(0);
#else
    /* on other platforms produce backtrace by aborting */
    abort();
    /* obviously cant continue */
#endif
}

backtrace.h

#ifndef _backtrace_h
#define _backtrace_h

#include <stdio.h>
#include "oslib/types.h"
#include "oslib/os.h"

#ifdef __cplusplus
   extern "C" {
#endif

/* ------------------------------------------------------------------------
 * Function:      exception_backtrace()
 *
 * Description:   Output a stack backtrace
 *
 * Inputs:        file - file to output to
 *                registers - array of register values
 */

extern void exception_backtrace (FILE *file, int const *registers);

/* ------------------------------------------------------------------------
 * Function:      exception_address_mask()
 *
 * Description:   returns the appropriate mask to use on addresses
 *                depending if running in 26 or 32 bit modes
 *
 * Output:        0x03FFFFFC in 26bit or 0xFFFFFFFF in 32bit
 */

extern int _exception_address_mask (void);

/* ------------------------------------------------------------------------
 * Function:      _exception_validate_pc()
 *
 * Description:   Check that a PC value is valid for the current program
 *
 * Inputs:        pc - the PC value to check
 *
 * Output:        Return true if the PC value is valid
 */

extern osbool _exception_validate_pc (int pc);

/* ------------------------------------------------------------------------
 * Function:      _exception_validate_address()
 *
 * Description:   Check that a range of addresses are valid for the
 *                current program
 *
 * Inputs:        min - the minimum address to check
 *                max - the maximum address to check
 *
 * Output:        Return true if the addresses are valid
 */

extern osbool _exception_validate_address (int min, int max);

/* ------------------------------------------------------------------------
 * Function:      _exception_registers()
 *
 * Description:   Gets the current contents of the machine registers
 *
 * Inputs:        registers - the array to fill in with register values
 */

extern void _exception_registers (int *registers);

#ifdef __cplusplus
   }
#endif

#endif

backtrace.c

#include <stdio.h>
#include "kernel.h"
#include "backtrace.h"

void exception_backtrace(FILE *file, int const *registers)
{
    os_platform_feature_flags features;
    unsigned int              fp;
    unsigned int              pc;
    unsigned int              mask = _exception_address_mask();

    if(xosplatformfeatures_get_features(&features, NULL))
    {
        features = 0;
    }

    fp = registers[11] & mask;

    if(_exception_validate_pc(registers[15] & mask))
    {
        pc = registers[15] & mask;
    }
    else if(_exception_validate_pc(registers[14] & mask))
    {
        pc = registers[14] & mask;
    }
    else
    {
        pc = 0;
    }

    while (pc && fp && _exception_validate_address(fp - 12, fp + 4))
    {
        unsigned int *frame = (unsigned int *)fp;
        unsigned int funcpc = frame[0] & mask;

        if((features & os_PLATFORM_PIPELINE_LENGTH2) != 0)
            funcpc += 4;

        if(_exception_validate_address(funcpc, funcpc + 4))
        {
            if(_exception_validate_address(funcpc - 28, funcpc - 8))
            {
                unsigned int ptr;
                char const   *procname = NULL;

                for (ptr = funcpc - 12; ptr >= funcpc - 28; ptr--)
                {
                    if((*(unsigned int *)ptr & 0xffffff00U) == 0xff000000U)
                    {
                        procname = (char *)ptr - (*(unsigned int *)ptr & 0xffU);
                        break;
                    }
                }

                if(procname)
                {
                    fprintf(file, "%20s(", procname);

                    if(_exception_validate_address(funcpc - 12, funcpc - 8))
                    {
                        if((*(unsigned int *)(funcpc - 12) & 0xffff0000U) == 0xe92d0000U)
                        {
                            unsigned int regmask = *(unsigned int *)(funcpc - 12) & 0xffffU;
                            int          i = 0;
                            int          r;

                            if((regmask & 0xF)!=0)
                            {
                                for (r = 15; r >= 0; r--)
                                {
                                    if((regmask & (1 << r)))
                                        i += 4;
                                }

                                for (r = 0; r <= 15; r++)
                                {
                                    if(regmask & (1 << r))
                                    {
                                        i -= 4;
                                        if(r<4 && _exception_validate_address(fp - i, fp - i + 4))
                                        {
                                            int value = *(int *)(fp - i);
                                            fprintf(file, "%s&%08X", r==0 ? "":", ", value);
                                        }
                                    } /* if regmask */
                                } /* for r */
                            }
                            else
                            {
                                for(r=0; r<8; r++)
                                {
                                    i+=4;
                                    int value = *(int *)(fp + i);
                                    fprintf(file, "%s&%08X", r==0 ? "":", ", value);
                                }
                            } /* if regmask */
                        } /* if *(unsigned int *) */
                    } /* if _exception_validate_address */
                    fprintf(file, ")\n");
                }
            }
        }

        if(fp == (frame[-3] & mask))
        {
            fprintf(file, "backtrace aborted: fp unchanged at %x\n", fp);
            fp = 0;
            pc = 0;
        }
        else
        {
            fp = frame[-3] & mask;
            pc = frame[-1] & mask;
        }
    }

    if(fp && pc)
    {
        fprintf(file, "backtrace aborted: stack frame has gone out of bounds with address &%X\n",
                      fp - 12);
    }
    else if(fp)
    {
        fprintf(file, "backtrace aborted: pc invalid\n");
    }

    return;
}

registers.s

    GET    oslib.Hdr.OS

    IMPORT    |Image$$RO$$Base|
    IMPORT    |Image$$RO$$Limit|

    AREA    |backtrace$$Code|,CODE,READONLY

    MACRO
    RET
    [ {CONFIG}=26
        MOVS     pc,r14
    |
        MOV      pc,r14
    ]
    MEND

    MACRO
    RETVS
    [ {CONFIG}=26
        MOVVSS     pc,r14
    |
        MOVVS      pc,r14
    ]
    MEND

;
; int _exception_address_mask(void)
;
        EXPORT    |_exception_address_mask|
|_exception_address_mask|
        MVN    a1,#0
        TEQ    pc,#0
        TEQ    pc,pc
        BICNE  a1,a1,#&FC000003
        RET

;
; void _exception_registers(int *registers)
;
        EXPORT    |_exception_registers|
|_exception_registers|
        STMIA  r0,{r0-r15}^
        RET

;
; bool _exception_validate_pc(int pc)
;
        EXPORT    |_exception_validate_pc|
|_exception_validate_pc|
        MOV    r3,r0
        LDR    r1,=|Image$$RO$$Base|
        CMP    r3,r1
        BLT    |_exception_validation_pc_tryrma|
        LDR    r1,=|Image$$RO$$Limit|
        CMP    r3,r1
        BLT    |_exception_validation_pc_ok|
|_exception_validation_pc_tryrma|
        MOV    R0,#OS_DynamicAreaRMA
        SWI    OS_ReadDynamicArea
        CMP    r3,r0
        BLT    |_exception_validation_pc_tryrom|
        ADD    r0,r0,r1
        CMP    r3,r0
        BLT    |_exception_validation_pc_ok|
|_exception_validation_pc_tryrom|
        MOV    r0,#(OSMemory_TypeROM :SHL: OSMemory_TypeShift) :OR: OSMemory_ReadSize
        SWI    XOS_Memory
        MOVVS  r0,#&03400000
        MOVVS  r1,#&03800000
        BVS    |_exception_validation_pc_tryrom2|
        CMP    r1,#0
        MOVNE  r0,#&03800000
        BNE    |_exception_validation_pc_tryrom1|
        MOV    r0,#(OSMemory_ControllerTypeExtensionROMs :SHL: OSMemory_TypeShift)
        ORR    r0,r0,#OSMemory_ReadSize
        SWI    XOS_Memory
        MOV    r0,#&FC000000
        MOV    r0,r3
|_exception_validation_pc_tryrom1|
        MLANE  r1,r2,r1,r0
|_exception_validation_pc_tryrom2|
        CMP    r3,r0
        BLT    |_exception_validation_pc_failed|
        CMP    r3,r1
        BGE    |_exception_validation_pc_failed|
|_exception_validation_pc_ok|
        MOV    r0,#1
        RET
|_exception_validation_pc_failed|
        MOV    r0,#0
        RET

; bool _exception_validate_address(int min, int max)
;
        EXPORT  |_exception_validate_address|
|_exception_validate_address|
        SWI    XOS_ValidateAddress
        MOVVS  r0,#0
        RETVS
        MOVCC  r0,#1
        MOVCS  r0,#0
        RET

        END

I don’t know what is up with the formatting on here, but if you want usable files, drop me an email.

[Edit]

Grrr. Trying lots of combinations of <pre><code>arrrh</code></pre> and it was messing up in many varied ways, until I discovered the one which worked had a blank line between the filename and the code block.

That code is over 20 years old, so I’m not sure stuff like the ROM location is valid anymore.

David, thanks so much for posting this. I need to study it and work out how it works!

for (ptr = funcpc - 12; ptr >= funcpc - 28; ptr--)

Surely needs a ptr-=4 as ptr isn’t a pointer in this code! Otherwise unaligned accesses will occur. Doesn’t fault on old systems and will crawl back bytewise to the procedure name if present, but some newer systems with the appropriate alignment options set will barf right when you don’t want them to in the middle of your attempt at debugging.

From a question on usenet some years ago, I published this as an example of how Doom traverses the backtrace when it reports errors (see the function I_Error):

https://usenet.gerph.org/SCL-Backtrace/

These days I rarely bother with capturing the backtrace within an application because the standard reporting used by the SCL will give sufficient information to explain what’s going on if an exception occurs, and will be captured in a diagnostic dump. On the other hand, it’s handy for those rare times when you want to inspect the state of the system at a given call. But it’s still a lot easier to just call the SWI to dump the entire state in those cases. Of course in Pyromaniac the same style of strack traversal is also done on any trace triggers.

Druck’s code looks a bit more complete, in any case.

The adventurous could burn themselves a SharedCLibrary with procedure names. In the RISCOS_Lib Makefile, the build rules which map c source files to the rm_o object files used to build the softload SharedCLibrary can be modified thus:

.c.rm_o:;     ${CC} ${CFLAGS} -fah -zm1 ${CSFLAGS} ${OPTIONS} -o $@ $<

where -fah replaces the existing -fafh option as -ff strips procedure names. Sadly you are out of luck with the wodges of assembler in the SCL as there are no macros there to dump procedure names in the output even if you wanted.

[Edit: Ignore this bit: There’s a common option C_NO_FNAMES in Makefiles.StdTools which specifies -ff to be passed to the C compiler. That can be emptied, or I think it can be overridden in the RISCOS_Lib Makefile?]

I prefer the _kernel_unwind() ways myself rather than doing it by hand. Quick and safe enough even to use on timer interrupts in a profiler.

Back in the times of the troubles – there was a softload CLib module – was that done all in ‘C’ ?

@Colin: Take a peek in the hard disc image’s !System – there’s still a soft-loadable CLib! However, as that has to work on any system, it’s not as optimised as the one found in your RISC OS 5 ROM which has been tuned for use with that particular system, using newer ARM instructions etc.

There has always been a good wodge of assembler in the C library. If it were all written in C, you’d be disappointed with its performance! The idea being that folk who know how to tune code for that architecture do it once so that everyone benefits, rather than you having to worry too much.

That said, it took a couple of years BITD to put a decent memcpy() into the C library to replace the generic one written in C. For shunting non-byte-aligned data around, ISTR about a factor of 13 was involved, so PipeDream used a homebrew implementation for years. In fact, until I stopped 26-bit builds, as the SharedCLibrary needed to provide decent memcpy() didn’t work on RISC OS 2.

Thanks, Charles, for the additional code sample, and everyone else for their various input.