HALCoGen generated code does not export stack addresses

I implement next functions

stack_utils_.asm:

	.data
userSp  .word 0
fiqSp   .word 0
svcSp   .word 0
irqSp   .word 0
abortSp .word 0
undefSp .word 0
	.def   userSp
    .def   fiqSp
    .def   svcSp
    .def   irqSp
    .def   abortSp
    .def   undefSp

	.text
	.arm

    .def     _ReadStackPointers_
    .asmfunc
_ReadStackPointers_
    cps   #17
	LDR  R0, fiqSpConst
	str  sp, [r0]

    cps   #18
	LDR  R0, irqSpConst
	str  sp, [r0]

    cps   #19
	LDR  R0, svcSpConst
	str  sp, [r0]

    cps  #23
	LDR  R0, abortSpConst
	str  sp, [r0]

    cps  #27
	LDR  R0, undefSpConst
	str  sp, [r0]

    cps   #31
	LDR  R0, userSpConst
	str  sp, [r0]

    bx    lr

    .endasmfunc

userSpConst  .word userSp
fiqSpConst   .word fiqSp
svcSpConst   .word svcSp
irqSpConst   .word irqSp
abortSpConst .word abortSp
undefSpConst .word undefSp

stack_utils.h:

#ifndef __STACK_UTILS_H_
#define __STACK_UTILS_H_

#include <stdint.h>
#include "oprintf.h"
#include "rx_stdbool.h"

typedef struct {
    uint16_t size;
    uint16_t used;
    uint32_t base;
} stack_info_t;

typedef struct {
    stack_info_t user;
    stack_info_t svc;
    stack_info_t fiq;
    stack_info_t irq;
    stack_info_t abort;
    stack_info_t undef;
} stacks_info_t;

void _ReadStackPointers_ (void);
uint16_t get_user_stack_free (void);

void read_stacks_info(stacks_info_t* info);
bool diag_report_stack(ostream_t* stream);
#endif /* __STACK_UTILS_H_ */

stack_utils.c:

#include <inttypes.h>
#include "stack_utils.h"
#include "log.h"
#include "diag_report.h"
#include "rx_io.h"
#include "table_utils.h"

extern uint32_t userSp;
extern uint32_t svcSp;
extern uint32_t fiqSp;
extern uint32_t irqSp;
extern uint32_t abortSp;
extern uint32_t undefSp;

#define USER_STACK_HEAD ((const uint32_t*)0x08000000)

#define RAM_HEAD 0x08000000U

#define SVC_STACK_SIZE 0x100

uint16_t get_user_stack_free (void) {
    const uint32_t* p = USER_STACK_HEAD;
    while (*p == 0) {
        p++;
    }
    return (uint16_t) ((p - USER_STACK_HEAD) * 4);
}

static void get_used (stack_info_t* s) {
    const uint8_t* head = (const uint8_t*) (s->base - s->size);
    uint32 free_size = 0;
    while (head [free_size] == 0 && free_size < s->size) {
        free_size++;
    }
    s->used = s->size - free_size;
}

void read_stacks_info (stacks_info_t* info) {
    RAISE_PRIVILEGE;
    _ReadStackPointers_ ();
    info->undef.base = undefSp;
    info->undef.size = undefSp - abortSp;
    get_used (&info->undef);

    info->abort.base = abortSp;
    info->abort.size = abortSp - irqSp;
    get_used (&info->abort);

    info->irq.base = irqSp;
    info->irq.size = irqSp - fiqSp;
    get_used (&info->irq);

    info->fiq.base = fiqSp;
    info->fiq.size = fiqSp - svcSp;
    get_used (&info->fiq);

    info->svc.base = svcSp;
    info->svc.size = SVC_STACK_SIZE;
    get_used (&info->svc);

    info->user.base = svcSp - SVC_STACK_SIZE;
    info->user.size = info->user.base - RAM_HEAD;
    get_used (&info->user);
    RESET_PRIVILEGE;
}

#define REPORT(name)   oprintf(stream, "║%6s │%5" PRIu16 " │%5" PRIu16 " │%5" PRIu16 " │%5" PRIu16 " ║" _SE, #name, info.name.size, info.name.used, info.name.size-info.name.used, (uint16_t)(info.name.used*100LU/info.name.size))

bool diag_report_stack (ostream_t* stream) {
    static stacks_info_t info;
    static const table_col_t cols [] =
        {
            { 7, "Stack" },
            { 6, "Size" },
            { 6, "Used" },
            { 6, "Free" },
            { 6, "% used" }, };

    table_header (stream, cols, RX_ARRAY_SIZE(cols));
    read_stacks_info (&info);
    REPORT(user);
    REPORT(svc);
    REPORT(fiq);
    REPORT(irq);
    REPORT(abort);
    REPORT(undef);
    table_row_bottom (stream, cols, RX_ARRAY_SIZE(cols));
    return true;
}