[连载]嵌入式实时操作系统TiniOS设计与实现

时飞大师兄

嵌入式实时操作系统TiniOS设计与实现

名称：TiniOS - Tiny and efficient IoT operating system for microcontrollers (RTOS)
芯片MCU：ARM Coterx-M3内核与MCS-51 8051内核，具体型号选用STM32F1系列与STC8系列。
开发平台：Keil v5 与 Code::Blocks+SDCC
代码许可：遵循MIT开源许可协议，可以免费在商业产品中使用，不需要公布应用源码，没有任何潜在商业风险。
源码托管网址：http://www.tinios.com

以微型嵌入式实时操作系统TiniOS V2.1.0为基础，逐步展开对系统的讲解，揭开嵌入式实时操作系统的神秘面纱。在讲解的过程中，我们尽量做到避免芯片型号之间的差异性，力争做到同系列芯片下的普适性。

欢迎论坛的朋友们加入，一起开发、完善。当然，也欢迎朋友们来撕、来踩……

时飞大师兄

为了方便嵌入式操作系统的跨平台移植，我们先为操作系统定义一些必要的数据类型，同时这些数据类型要尽量避免与用户应用程序的数据类型相冲突。

在此我们给系统定义基本的数据类型如下：

typedef unsigned   char                    uOS8_t;
typedef char                                sOS8_t;
typedef unsigned   short                  uOS16_t;
typedef signed     short                   sOS16_t;
typedef unsigned   int                    uOS32_t;
typedef signed     int                    sOS32_t;


typedef                uOS32_t                                 uOSStack_t;
typedef                sOS32_t                                 sOSBase_t;
typedef                uOS32_t                                 uOSBase_t;
typedef                uOS32_t                                 uOSTick_t;

typedef enum {OS_FALSE = 0, OS_TRUE = !OS_FALSE} uOSBool_t;
typedef enum {OS_SUCESS = 0, OS_ERROR = !OS_SUCESS} uOSStatus_t;

数据类型中的下划线 _t代表Type

下面我们定义一些和具体平台相关的一些参数，也就是和STM32F1相关的参数

#define                 FITSTACK_GROWTH                        ( -1 )
#define                FITBYTE_ALIGNMENT                ( 8 )

因为是和平台相关的，我们定义相关参数的前缀为FIT，代表需要根据不同的芯片类型进行调整。用此前缀也便于提醒用户，在进行系统移植时，一定要注意带有前缀fit相关的参数、变量和函数；

上述宏定义的参数中FITSTACK_GROWTH        代表栈增长的方向， 我们用-1代表从高位置向低位置增长，用1代表从低位置向高位值增长；宏定义参数FITBYTE_ALIGNMENT代表数据对齐方式；在Cortex-M3系列的STM32F1芯片中，栈增长方向为从高到低，我们定义为-1，芯片为32位宽的，我们定义8字节对齐；这两个参数对嵌入式操作系统的内存布局影响非常大，后面我们会具体分析！

时飞大师兄

嵌入式实时操作系统一般都运行在资源非常有限的芯片上，对内存管理要求比较严格，若使用方式比较粗放，很可能导致内存紧张。在此，我们先提出对内存管理的几点要求，后面再按照这个要求逐步实现。有兴趣的朋友也可以一起思考，共同实现！

对内存管理的相关要求如下：
1、在嵌入式操作系统未使用之前，为其分配的为一块连续的内存空间；
2、该内存空间可以由用户自由指定，即内存的起始位置可以进行配置，方便应用开发，也便于对内存的安全管理；
3、在用户使用时，可以从连续的内存块中自由取出指定大小的内存区域，以供专门的使用，比如为系统任务、消息队列、信号量、互斥锁等分配内存空间；
4、在用户释放内存空间后（如任务生命期结束，释放该任务占用的内存空间），可以由系统进行回收。若出现内存碎片，则相邻的内存碎片可以合并成一个较大的内存区域，供下次内存分配使用；

内存管理永远是一个操作系统中比较核心的内容，即使考虑的再周到也难以避免内存碎片的问题。尤其是动态内存的频繁分配与释放，往往会导致某些“破碎”的内存不可再次使用，尤其是嵌入式实时操作系统，内存资源更加宝贵。因此，在使用时，我们尽量把内存使用方式静态化——内存专用，即分给某一任务、消息队列、信号量或者互斥锁等的内存尽量固定下来，避免对内存的频繁分配与释放；

时飞大师兄

为嵌入式实时操作系统分配的内存大小可由用户进行配置。
#define OSMEM_SIZE                        OSTOTAL_HEAP_SIZE
用户可以通过上面的宏定义变量OSTOTAL_HEAP_SIZE进行配置，为系统分配特定大小的内存空间。上面我们对此进行再次定义，主要目的是与用户的配置隔离开，以便内存管理相关的函数操作不受用户配置的影响。下面内存管理相关的操作变量均采用宏定义变量OSMEM_SIZE实现；

由于嵌入式实时操作系统内存资源比较宝贵，在进行设计的时候，我们需要进行“量体裁衣”，尽量避免资源浪费的情况出现；接下来我们根据用户分配的内存大小设置内存控制变量的类型；
#if OSMEM_SIZE > 64000L
typedef uOS32_t uOSMemSize_t;
#else
typedef uOS16_t uOSMemSize_t;
#endif
上述代码比较简单明了，若用户定义的内存长度超出64000，我们使用uOS32_t作为内存管理的变量类型，若长度小于64000，则使用uOS16_t作为内存管理的变量类型；细心的朋友可能发现了，uOS16_t的表示范围到65535了，这里怎么使用64000作为分界线呢？是的，因为内存管理自身的相关操作也需要占用内存，这句话读起来好像有点拗口啊。在内存管理时，我们为内存块设置了若干个信息记录表（表的数量与内存块的数量是一一对应的），信息记录表用于记录该内存块的使用情况，如该内存块的前一个相邻内存块位置，后一个相邻内存块位置，以及该内存块是否已经被分配使用等等；冗余的1535个位置即为内存块记录信息使用，若系统中分配的内存块较多，则会占用的较多，一般情况下，1535的大小足够内存信息记录表使用了；

下面我们为内存定义最小可分配的内存块大小，默认为12个字节长；
#ifndef MIN_SIZE
#define MIN_SIZE             12
#endif
定义此最小内存块大小的目的也是为了避免内存区出现琐碎的碎片，从而导致碎片不可再次回收利用；

在内存定义实现之前，我们再来看一个内存对齐的宏定义；
#ifndef OSMEM_ALIGN_SIZE
#define OSMEM_ALIGN_SIZE(size) (((size) + OSMEM_ALIGNMENT - 1) & ~(OSMEM_ALIGNMENT-1))
#endif
在STM32F1系列的芯片中，我们定义OSMEM_ALIGNMENT为4字节对齐方式；通过OSMEM_ALIGN_SIZE的宏定义，我们可以获取4字节的整数倍数值，例如，若指定size大小为13或者15，则返回数值为16；

内存表信息结构体定义如下；
typedef struct _tOSMem
{
  uOSMemSize_t NextMem;        /*相邻的后一内存块地址 */
  uOSMemSize_t PrevMem;        /*相邻的前一内存块地址*/
  uOS8_t used;                        /*内存块的使用标志1: 该内存块已使用; 0: 未使用*/
}tOSMem_t;

对齐后的内存区块数值大小由如下宏定义实现：
#define SIZEOF_OSMEM_ALIGNED        OSMEM_ALIGN_SIZE(sizeof(tOSMem_t))
#define OSMEM_SIZE_ALIGNED                OSMEM_ALIGN_SIZE(OSMEM_SIZE)

下面就是操作系统内存区域具体的实现方式了：
#ifndef OSRAM_HEAP_POINTER
uOS8_t OSRamHeap[OSMEM_SIZE_ALIGNED + (2*SIZEOF_OSMEM_ALIGNED) + OSMEM_ALIGNMENT];
#define OSRAM_HEAP_POINTER OSRamHeap
#endif
上述OSRAM_HEAP_POINTER宏定义变量为系统所需的内存指针，该指针可由用户自行配置，指向具体的内存区。如若未配置，则通过数组的形式进行分配。
数组的长度=用户指定的长度+内存信息表的长度*2+内存对齐最小长度；
上述长度数值均是按照内存对齐方式处理过之后的长度数值；从上面的宏定义我们可以看出，若用户没有配置OSRAM_HEAP_POINTER的具体数值，系统则会把该变量指向数组OSRamHeap的首地址；

到现在，我们已经实现了上面提到的内存管理方面的第1和第2两项要求了，接着就是内存管理的具体实现方式了；

时飞大师兄

一些朋友看到我上面的描述可能会头晕目眩，不知所云。犹如苏轼那首经典古诗——题西林壁描述的一样：横看成岭侧成峰，远近高低各不同。不识庐山真面目，只缘身在此山中。这时，朋友们需要跳出这个圈子，从整体上对系统的内存管理进行重新认识。下面我们从整体上给内存管理功能“画一个轮廓”。

在刚刚为系统分配内存区域之后，这块内存区域一定是一个连续的空间。为了便于管理，我们在这块连续的内存空间中插入内存块信息头，记录内存块的基本信息：即前面提到的与该内存块相邻的前一块内存地址，后一块内存地址，当前内存块是否已经被分配使用等等；下图即为刚刚分配完的内存分布示意图；


图示：刚刚分配完毕时的内存分布示意图

为了便于管理，我们采用全局变量gpOSMemBegin记录第一块内存地址，用全局变量gpOSMemEnd记录最后一块的内存地址；同时为了方便更快速的分配内存，我们用全局变量gpOSMemLFree记录第一块未被分配使用的内存地址；

从上图中我们可以看出，对于刚刚分配好的内存区域，我们对其初始化为两个内存块；第一个内存块标记为未被使用的内存块，信息参数Used设置为0。其信息参数NextMem初始化为OSMEM_SIZE_ALIGNED，即指向最后一个内存块信息头。因为其自身就是第一个内存块，前面已经没有可用内存块了，我们把其参数PrevMem初始化为0。我们把第二个内存块设置为最后一个内存块，永远不能被系统分配使用，仅仅用其记录内存区域的尾部，因此其信息参数Used设置为1，表示已经使用，无法被系统再次分配使用。该内存块的信息参数NextMem与PrevMem均初始化为OSMEM_SIZE_ALIGNED，即永远指向自己。

至此，系统的内存区域已经初始化完毕了，下面请朋友们猜想一下，系统具体是如何分配使用内存的呢？没错，从第一个内存块切分！是的，系统若需要使用某一大小的内存块，则需要从上述初始化完毕的第一个内存块中切分出一块使用。为了方便管理，系统需要把切分出的内存块信息记录下来，并标记上已经在使用了；若系统运行一段时间后，某一块具体内存块不再需要了，就需要把该内存块释放掉。所谓内存释放也比较简单，只需要把内存块的使用标志清除掉即可。为了便于检测，在清除内存时，也可以把内存区设置为默认值。


图示：系统运行一段时间之后的内存分布示意图

上图表示运行一段时间之后系统的内存分布示意图；上图为了画图方便，指针的指示位置有所出入；在实际使用中，内存块信息参数中的NextMem指向下一个内存块信息的首地址，内存块信息参数PrevMem指向前一个内存块信息的首地址。

为了防止内存出现碎片的情况，我们在内存释放时还需要对相邻的前后内存使用情况进行检测，若相邻区域的内存块未使用，则需要把这两个相邻的未被使用的内存块合并起来；

时飞大师兄

经过几天的筛选，决定给这个嵌入式实时操作系统命名为“AIOS”。

熟悉电脑的朋友都知道BIOS系统，其英文含义就是Basic Input Output System，翻译过来就是“基本输入输出系统”，它是一组固化到计算机内主板上一个ROM芯片上的程序，它保存着计算机最重要的基本输入输出的程序、开机后自检程序和系统自启动程序。 其主要功能是为计算机提供最底层的、最直接的硬件设置和控制。

BIOS系统一般在刚上电后进行基本配置、引导启动，其后就自行退出了。咱这个嵌入式系统则会伴随着芯片与用户的应用程序实时运行，不谦虚一把，取名曰“AIOS”，即Advanced Input Output System，高级输入输出系统；

身边有朋友看到AIOS，立马想到Artificial Intelligence Operating System，与当前非常热门的人工智能联系了起来，呵呵，不敢奢望，不敢奢望！

嵌入式实时操作系统AIOS，欢迎朋友们来撕……

时飞大师兄

描述完毕“内存管理”的整个轮廓之后，我们来查看具体的内存管理函数是怎么实现的；

首先我们查看一下内存初始化函数OSMemInit，这个函数很简单，主要为全局变量gpOSMemBegin，gpOSMemEnd与gpOSMemLFree分配初始数值；

1. /*****************************************************************************
   
2. Function    : OSMemInit
   
3. Description : Zero the heap and initialize start, end and lowest-free pointer.
   
4. Input       : None
   
5. Output      : None
   
6. Return      : None
   
7. *****************************************************************************/
   
8. void OSMemInit(void)
   
9. {
   
10.         tOSMem_t *ptOSMemTemp;
    
11. 
    
12.         // align the heap
    
13.         gpOSMemBegin = (uOS8_t *)OSMEM_ALIGN_ADDR(OSRAM_HEAP_POINTER);
    
14.         
    
15.         // initialize the start of the heap
    
16.         ptOSMemTemp = (tOSMem_t *)(void *)gpOSMemBegin;
    
17.         ptOSMemTemp->NextMem = OSMEM_SIZE_ALIGNED;
    
18.         ptOSMemTemp->PrevMem = 0;
    
19.         ptOSMemTemp->Used = 0;
    
20.         
    
21.         // initialize the end of the heap
    
22.         gpOSMemEnd = (tOSMem_t *)(void *)&gpOSMemBegin[OSMEM_SIZE_ALIGNED];
    
23.         gpOSMemEnd->Used = 1;
    
24.         gpOSMemEnd->NextMem = OSMEM_SIZE_ALIGNED;
    
25.         gpOSMemEnd->PrevMem = OSMEM_SIZE_ALIGNED;
    
26. 
    
27.         // initialize the lowest-free pointer to the start of the heap
    
28.         gpOSMemLFree = (tOSMem_t *)(void *)gpOSMemBegin;
    
29. }
    

复制代码

接着是内存分配函数。

1. /*****************************************************************************
   
2. Function    : OSMemMalloc
   
3. Description : Allocate a block of memory with a minimum of 'size' bytes.
   
4. Input       : size -- the minimum size of the requested block in bytes.
   
5. Output      : None
   
6. Return      : pointer to allocated memory or OS_NULL if no free memory was found.
   
7.               the returned value will always be aligned (as defined by OSMEM_ALIGNMENT).
   
8. *****************************************************************************/
   
9. void* OSMemMalloc(uOSMemSize_t size)
   
10. {
    
11.         uOS8_t * pResult = OS_NULL;
    
12.         uOSMemSize_t ptr, ptr2;
    
13.         tOSMem_t *ptOSMemTemp, *ptOSMemTemp2;
    
14. 
    
15.         if(gpOSMemEnd==OS_NULL)
    
16.         {
    
17.                 OSMemInit();
    
18.                 if(gpOSMemEnd==OS_NULL)
    
19.                 {
    
20.                         return pResult;
    
21.                 }
    
22.         }
    
23.         if (size == 0)
    
24.         {
    
25.                 return pResult;
    
26.         }
    
27. 
    
28.         // Expand the size of the allocated memory region so that we can
    
29.         // adjust for alignment.
    
30.         size = OSMEM_ALIGN_SIZE(size);
    
31. 
    
32.         if(size < OSMIN_SIZE_ALIGNED)
    
33.         {
    
34.                 // every data block must be at least OSMIN_SIZE_ALIGNED long
    
35.                 size = OSMIN_SIZE_ALIGNED;
    
36.         }
    
37. 
    
38.         if (size > OSMEM_SIZE_ALIGNED)
    
39.         {
    
40.                 return pResult;
    
41.         }
    
42. 
    
43.         // protect the heap from concurrent access
    
44.         <font color="#000000"><span style="font-size: 15px; line-height: 22.5px;">OSIntLock</span></font>();
    
45. 
    
46.         // Scan through the heap searching for a free block that is big enough,
    
47.         // beginning with the lowest free block.
    
48.         for (ptr = (uOSMemSize_t)((uOS8_t *)gpOSMemLFree - gpOSMemBegin); ptr < OSMEM_SIZE_ALIGNED - size;
    
49.                 ptr = ((tOSMem_t *)(void *)&gpOSMemBegin[ptr])->NextMem)
    
50.         {
    
51.                 ptOSMemTemp = (tOSMem_t *)(void *)&gpOSMemBegin[ptr];
    
52. 
    
53.                 if ((!ptOSMemTemp->Used) && (ptOSMemTemp->NextMem - (ptr + SIZEOF_OSMEM_ALIGNED)) >= size)
    
54.                 {
    
55.                         // ptOSMemTemp is not Used and at least perfect fit is possible:
    
56.                         // ptOSMemTemp->NextMem - (ptr + SIZEOF_OSMEM_ALIGNED) gives us the 'user data size' of ptOSMemTemp
    
57. 
    
58.                         if (ptOSMemTemp->NextMem - (ptr + SIZEOF_OSMEM_ALIGNED) >= (size + SIZEOF_OSMEM_ALIGNED + OSMIN_SIZE_ALIGNED))
    
59.                         {
    
60.                                 // (in addition to the above, we test if another tOSMem_t (SIZEOF_OSMEM_ALIGNED) containing
    
61.                                 // at least OSMIN_SIZE_ALIGNED of data also fits in the 'user data space' of 'ptOSMemTemp')
    
62.                                 // -> split large block, create empty remainder,
    
63.                                 // remainder must be large enough to contain OSMIN_SIZE_ALIGNED data: if
    
64.                                 // ptOSMemTemp->NextMem - (ptr + (2*SIZEOF_OSMEM_ALIGNED)) == size,
    
65.                                 // tOSMem_t would fit in but no data between ptOSMemTemp2 and ptOSMemTemp2->NextMem
    
66.                                 ptr2 = ptr + SIZEOF_OSMEM_ALIGNED + size;
    
67.                                 // create ptOSMemTemp2 struct
    
68.                                 ptOSMemTemp2 = (tOSMem_t *)(void *)&gpOSMemBegin[ptr2];
    
69.                                 ptOSMemTemp2->Used = 0;
    
70.                                 ptOSMemTemp2->NextMem = ptOSMemTemp->NextMem;
    
71.                                 ptOSMemTemp2->PrevMem = ptr;
    
72.                                 // and insert it between ptOSMemTemp and ptOSMemTemp->NextMem
    
73.                                 ptOSMemTemp->NextMem = ptr2;
    
74.                                 ptOSMemTemp->Used = 1;
    
75. 
    
76.                                 if (ptOSMemTemp2->NextMem != OSMEM_SIZE_ALIGNED)
    
77.                                 {
    
78.                                         ((tOSMem_t *)(void *)&gpOSMemBegin[ptOSMemTemp2->NextMem])->PrevMem = ptr2;
    
79.                                 }
    
80.                         }
    
81.                         else
    
82.                         {
    
83.                                 // (a ptOSMemTemp2 struct does no fit into the user data space of ptOSMemTemp and ptOSMemTemp->NextMem will always
    
84.                                 // be Used at this point: if not we have 2 unused structs in a row, OSMemCombine should have
    
85.                                 // take care of this).
    
86.                                 // -> near fit or excact fit: do not split, no ptOSMemTemp2 creation
    
87.                                 // also can't move ptOSMemTemp->NextMem directly behind ptOSMemTemp, since ptOSMemTemp->NextMem
    
88.                                 // will always be Used at this point!
    
89.                                 ptOSMemTemp->Used = 1;
    
90.                         }
    
91. 
    
92.                         if (ptOSMemTemp == gpOSMemLFree)
    
93.                         {
    
94.                                 // Find next free block after ptOSMemTemp and update lowest free pointer
    
95.                                 while (gpOSMemLFree->Used && gpOSMemLFree != gpOSMemEnd)
    
96.                                 {
    
97.                                         gpOSMemLFree = (tOSMem_t *)(void *)&gpOSMemBegin[gpOSMemLFree->NextMem];
    
98.                                 }
    
99.                         }
    
100.                         pResult = (uOS8_t *)ptOSMemTemp + SIZEOF_OSMEM_ALIGNED;
     
101.                         break;
     
102.                 }
     
103.         }
     
104. 
     
105.         OSIntUnlock();
     
106. 
     
107.         return pResult;
     
108. }

复制代码

内存释放函数。

1. /*****************************************************************************
   
2. Function    : OSMemFree
   
3. Description : Put a tOSMem_t back on the heap.
   
4. Input       : pMem -- the data portion of a tOSMem_t as returned by a previous
   
5.                       call to OSMemMalloc()
   
6. Output      : None
   
7. Return      : None
   
8. *****************************************************************************/
   
9. void OSMemFree(void *pMem)
   
10. {
    
11.         tOSMem_t *ptOSMemTemp;
    
12. 
    
13.         if (pMem == OS_NULL)
    
14.         {
    
15.                 return;
    
16.         }
    
17. 
    
18.         if ((uOS8_t *)pMem < (uOS8_t *)gpOSMemBegin || (uOS8_t *)pMem >= (uOS8_t *)gpOSMemEnd)
    
19.         {
    
20.                 return;
    
21.         }
    
22.         
    
23.         // protect the heap from concurrent access
    
24.         OSIntLock();
    
25.         // Get the corresponding tOSMem_t ...
    
26.         ptOSMemTemp = (tOSMem_t *)(void *)((uOS8_t *)pMem - SIZEOF_OSMEM_ALIGNED);
    
27.         
    
28.         //ptOSMemTemp->Used must be 1
    
29.         if( ptOSMemTemp->Used==1 )
    
30.         {
    
31.                 // now set it unused.
    
32.                 ptOSMemTemp->Used = 0;
    
33. 
    
34.                 if (ptOSMemTemp < gpOSMemLFree)
    
35.                 {
    
36.                         // the newly freed struct is now the lowest
    
37.                         gpOSMemLFree = ptOSMemTemp;
    
38.                 }
    
39. 
    
40.                 // finally, see if prev or next are free also
    
41.                 OSMemCombine(ptOSMemTemp);               
    
42.         }
    
43.         OSIntUnlock();
    
44.         
    
45.         return;
    
46. }
    

复制代码

代码已经更新到Github上了，感兴趣的朋友请移步到Github查看更多源代码。

到现在，我们已经实现了上面提到的内存管理方面的第3和第4两项要求了。这样，嵌入式实时操作系统AIOS的内存管理已经基本实现了；

由于大部分的微控制器芯片资源非常有限，部分嵌入式操作系统在设计时没有单独的内存管理模块，而是在使用时临时分配。例如ucos嵌入式操作系统，在创建任务时，总是通过一个数组的形式分配一段内存空间，然后把数组的首地址及长度传递给待创建的任务使用。这样相当于把内存管理分散化，但是如果要整体设置系统的内存位置就不那么方便了。

时飞大师兄

内存管理已经基本完成了，在进行下一步开发之前，我们先熟悉一下ARM汇编编程规则：

1. 基本概念
   &#8226; ATPCS (ARM-Thumb Procedure Call Standard)

    规定了一些子程序间调用的基本规则，这些规则包括子程序调用过程中寄存器的使用规则，数据栈的使用规则，参数的传递规则。有了这些规则之后，单独编译的C语言程序就可以和汇编程序相互调用。
    使用ADS的C语言编译器编译的C语言子程序满足用户指定的ATPCS类型。而对于汇编语言来说，则需要用户来保证各个子程序满足ATPCS的要求。
   &#8226; AAPCS (ARM Archtecture Procedure Call Standard)

     2007年ARM公司正式推出了AAPCS标准，AAPCS是ATPCS的改进版，目前， AAPCS和ATPCS都是可用的标准。

2. 寄存器使用规则
    &#8226; 子程序间通过寄存器R0～R3来传递参数。这时，寄存器R0～R3可记作a0～a3。被调用的子程序在返回前无需恢复寄存器R0～R3的内容。

    &#8226; 在子程序中，使用寄存器R4～R11来保存局部变量。这时，寄存器R4～R11可以记作v1～v8。如果在子程序中使用了寄存器v1～v8中的某些寄存器，则子程序进入时必须保存这些寄存器的值，在返回前必须恢复这些寄存器的值。在Thumb程序中，通常只能使用寄存器R4～R7来保存局部变量。

   &#8226; 寄存器R12用作过程调用中间临时寄存器，记作IP。在子程序之间的连接代码段中常常有这种使用规则。

   &#8226; 寄存器R13用作堆栈指针，记作SP。在子程序中寄存器R13不能用作其他用途。寄存器SP在进入子程序时的值和退出子程序时的值必须相等。
   &#8226; 寄存器R14称为连接寄存器，记作LR。它用于保存子程序的返回地址。如果在子程序中保存了返回地址，寄存器R14则可以用作其他用途。
   &#8226; 寄存器R15是程序计数器，记作PC。它不能用作其它用途。

3. 堆栈使用规则

   &#8226; ATPCS规定堆栈为FD(Full Descending: sp指向最后一个压入的值，数据栈由高地址向低地址生长)类型，即满递减堆栈，并且对堆栈的操作是8字节对齐。所以经常使用的指令就有STMFD和LDMFD。
   &#8226;对于汇编程序来说，如果目标文件中包含了外部调用，则必须满足下列条件：
   （1）外部接口的堆栈必须是8字节对齐的。   
   （2）在汇编程序中使用PRESERVE8伪指令告诉连接器，本汇编程序数据是8字节对齐的。

4. 参数传递规则

    &#8226; 根据参数个数是否固定，可以将子程序分为参数个数固定的子程序和参数个数可变化的子程序。
    &#8226; 这两种子程序的参数传递规则是不一样的。

4.1 参数个数可变子程序参数传递规则

    &#8226; 对于参数个数可变的子程序，当参数个数不超过4个时，可以使用寄存器R0～R3来传递参数；当参数超过4个时，还可以使用堆栈来传递参数。
    &#8226; 在传递参数时，将所有参数看作是存放在连续的内存字单元的字数据。然后，依次将各字数据传递到寄存器R0，R1，R2和R3中。如果参数多于4个，则将剩余的字数据传递到堆栈中。入栈的顺序与参数传递顺序相反，即最后一个字数据先入栈。

4.2 参数个数固定子程序参数传递规则

    &#8226; 如果系统不包含浮点运算的硬件部件，浮点参数会通过相应的规则转换成整数参数（若没有浮点参数，此步省略），然后依次将各字数据传送到寄存器R0～R3中。如果参数多于4个，将剩余的字数据传送堆栈中，入栈的顺序与参数顺序相反，即最后一个字数据先入栈。在参数传递时，将所有参数看作是存放在连续的内存字单元的字数据。

5. 子程序结果返回规则
    子程序中结果返回的规则如下：
    &#8226; 结果为一个32位整数时，可以通过寄存器R0返回；
    &#8226; 结果为一个64位整数时，可以通过寄存器R0和R1返回；
    &#8226; 结果为一个浮点数时，可以通过浮点运算部件的寄存器f0、d0或s0来返回；
    &#8226; 结果为复合型浮点数（如复数）时，可以通过寄存器f0～fn或d0～dn来返回；
    &#8226; 对于位数更多的结果，需要通过内存来传递。