关于cortexM0堆栈分配

// Set up initial stack and heap

__value_in_regs struct __initial_stackheap

__user_initial_stackheap(unsigned R0, unsigned SP, unsigned R2, unsigned SL)

{        

  struct __initial_stackheap s;

        

  s.heap_base   = R0;         /* low-address end of initial heap */

  s.stack_base  = SP;         /* high-address end of initial stack */

  s.heap_limit  = s.stack_base; /* high-address end of initial heap */

  s.stack_limit = s.heap_base; /* low-address end of initial stack */

  return s;

}

/*

This must return a pointer to __USER_LIBSPACE_SIZE bytes of zero-initialised space, used to store vital static data such as

errno, the heap state, and the FP status word.*/

#define __USER_LIBSPACE_SIZE 96

extern void *__user_libspace(void);



/*

 * This can be defined to override the standard memory models' way

 * of determining where to put the initial stack and heap.

 *

 * The input parameters R0 and R2 contain nothing useful. The input

 * parameters SP and SL are the values that were in SP and SL when

 * the program began execution (so you can return them if you want

 * to keep that stack).

 *

 * The two `limit' fields in the return structure are ignored if

 * you are using the one-region memory model: the memory region is

 * taken to be all the space between heap_base and stack_base.

 */

struct __initial_stackheap {

    unsigned heap_base;                /* low-address end of initial heap */

    unsigned stack_base;               /* high-address end of initial stack */

    unsigned heap_limit;               /* high-address end of initial heap */

    unsigned stack_limit;              /* low-address end of initial stack */

};

extern __value_in_regs struct __initial_stackheap

__user_initial_stackheap(unsigned /*R0*/, unsigned /*SP*/,

                         unsigned /*R2*/, unsigned /*SL*/);



/*

 * This can be defined to give bounds on the address space the heap

 * will ever use.

 */

struct __heap_extent {

    unsigned base, range;

};

extern __value_in_regs struct __heap_extent

__user_heap_extent(unsigned /*ignore*/, unsigned /*ignore*/);



/*

 * This can be defined to specify how much spare stack is needed

 * below SL in addition to the 256 bytes required by ATPCS:

 * `always' gives the number of bytes of extra stack required at

 * all instants (so that an interrupt handler has space to run in,

 * for example), while `cleanup' gives the number of bytes of extra

 * stack required to be available after a stack overflow has

 * occurred, so that the stack overflow routine (e.g. SIGSTAK

 * handler) has room to tidy up.

 */

struct __stack_slop {

    unsigned always, cleanup;

};

extern __value_in_regs struct __stack_slop

__user_stack_slop(unsigned /*ignore*/, unsigned /*ignore*/);



/*

 * This can be defined to return extra blocks of memory, separate

 * from the initial one, to be used by the heap. It should place a

 * pointer to a block of at least the requested size in `*base',

 * and return the size of the block. It should return 0 if no such

 * block can be returned, in which case the value stored at `*base'

 * is never used.

 */

extern unsigned __user_heap_extend(int /*ignore*/,

                                   void ** /*base*/,

                                   unsigned /*requestedsize*/);