ecos的中断ISR是怎么与硬件中断向量联系起来的，是怎么被调用的?

本文整理自：http://keendawn.blog.163.com/blog/static/8888074320116205833478/

要想知道ecos的中断ISR是怎么与硬件中断向量联系起来的，是怎么被调用的?

那就要看下面这两个关键的函数：

1. cyg_drv_interrupt_create()
   
2. cyg_drv_interrupt_attach()

复制代码

这两个函数都声明在cyg/kernel/kapi.h中，其形式如下：

1. void cyg_interrupt_create(
   
2.     cyg_vector_t        vector,         /* Vector to attach to               */
   
3.     cyg_priority_t      priority,       /* Queue priority                    */
   
4.     cyg_addrword_t      data,           /* Data pointer                      */
   
5.     cyg_ISR_t           *isr,           /* Interrupt Service Routine         */
   
6.     cyg_DSR_t           *dsr,           /* Deferred Service Routine          */
   
7.     cyg_handle_t        *handle,        /* returned handle                   */
   
8.     cyg_interrupt       *intr           /* put interrupt here                */
   
9. ) __THROW;
   
10. 
    
11. void cyg_interrupt_attach( cyg_handle_t interrupt ) __THROW;

复制代码

（注: __THROW是在C++中用的,是用来抛出异常的，详见： eCos中的externC和__THROW 这篇帖子的说明）。

其中文意义对照如下:
cyg_interrupt_create(
        中断号,
        中断优先级,
        传递的中断参数,
        ISR函数,
        DSR函数,
        被返回的中断句柄,
        存放与此中断相关的内核数据的变量空间);

cyg_interrupt_attach(中断句柄);

这样实际上去研究一下cyg_interrupt_create函数的定义内容，应该就能搞明白我们的问题了!
由于其函数声明在kapi.h中，很自然的就想到其定义应在kapi.c文件中。
找到 文件： ....\ecos\ecos-current\packages\kernel\current\src\common\kapi.cxx

找到这两个函数的定义如下：

1. /*---------------------------------------------------------------------------*/
   
2. /* Interrupt handling                                                        */
   
3. 
   
4. externC void cyg_interrupt_create(
   
5.     cyg_vector_t        vector,         /* Vector to attach to               */
   
6.     cyg_priority_t      priority,       /* Queue priority                    */
   
7.     cyg_addrword_t      data,           /* Data pointer                      */
   
8.     cyg_ISR_t           *isr,           /* Interrupt Service Routine         */
   
9.     cyg_DSR_t           *dsr,           /* Deferred Service Routine          */
   
10.     cyg_handle_t        *handle,        /* returned handle                   */
    
11.     cyg_interrupt       *intr           /* put interrupt here                */
    
12. ) __THROW
    
13. {
    
14.     CYG_ASSERT_SIZES( cyg_interrupt, Cyg_Interrupt );
    
15. 
    
16.     Cyg_Interrupt *t = new((void *)intr) Cyg_Interrupt (
    
17.         (cyg_vector)vector,
    
18.         (cyg_priority)priority,
    
19.         (CYG_ADDRWORD)data,
    
20.         (cyg_ISR *)isr,
    
21.         (cyg_DSR *)dsr );
    
22.     t=t;
    
23. 
    
24.     CYG_CHECK_DATA_PTR( handle, "Bad handle pointer" );
    
25.     *handle = (cyg_handle_t)intr;
    
26. }
    
27. 
    
28. void cyg_interrupt_attach( cyg_handle_t interrupt ) __THROW
    
29. {
    
30.     ((Cyg_Interrupt *)interrupt)->attach();
    
31. }

复制代码

函数内容比想象中的简单，所有的操作又都传给了Cyg_Interrupt这个类来完成，那就来对Cyg_Interrupt探个究竟吧。

注意：Cyg_Interrupt是个C++类,，可不要找成了struct cyg_interrupt，注意哟，cyg_interrupt_create函数的最后一个参数就是这个cyg_interrupt struct类型的，在cyg/kernel/kapidata.h中有个struct cyg_interrupt定义，虽然名字和内容都很相似，但实际上不是。

真正的class Cyg_Interrupt定义在cyg/kernel/intr.hxx中，这个头文件没干别的，就是声明这个class了，可见这是一个很大的class，如下：

1. // -------------------------------------------------------------------------
   
2. // Interrupt class. This both represents each interrupt and provides a static
   
3. // interface for controlling the interrupt hardware.
   
4. 
   
5. class Cyg_Interrupt
   
6. {
   
7. 
   
8.     friend class Cyg_Scheduler;
   
9.     friend void interrupt_end( cyg_uint32,
   
10.                                Cyg_Interrupt *,
    
11.                                HAL_SavedRegisters *);
    
12.     friend void cyg_interrupt_post_dsr( CYG_ADDRWORD intr_obj );
    
13.     friend void cyg_interrupt_call_pending_DSRs( void );
    
14.    
    
15.     cyg_vector          vector;         // Interrupt vector
    
16. 
    
17.     cyg_priority        priority;       // Queuing priority
    
18.    
    
19.     cyg_ISR             *isr;           // Pointer to ISR
    
20. 
    
21.     cyg_DSR             *dsr;           // Pointer to DSR
    
22. 
    
23.     CYG_ADDRWORD        data;           // Data pointer
    
24. 
    
25. 
    
26.    
    
27.     // DSR handling interface called by the scheduler
    
28. 
    
29.                                         // Check for pending DSRs
    
30.     static cyg_bool     DSRs_pending();
    
31. 
    
32.                                         // Call any pending DSRs
    
33.     static void         call_pending_DSRs();
    
34.     static void         call_pending_DSRs_inner();
    
35. 
    
36.     // DSR handling interface called by the scheduler and HAL
    
37.     // interrupt arbiters.
    
38. 
    
39.     void                post_dsr();     // Post the DSR for this interrupt
    
40. 
    
41. 
    
42.    
    
43.     // Data structures for handling DSR calls.  We implement two DSR
    
44.     // handling mechanisms, a list based one and a table based
    
45.     // one. The list based mechanism is safe with respect to temporary
    
46.     // overloads and will not run out of resource. However it requires
    
47.     // extra data per interrupt object, and interrupts must be turned
    
48.     // off briefly when delivering the DSR. The table based mechanism
    
49.     // does not need unnecessary interrupt switching, but may be prone
    
50.     // to overflow on overload. However, since a correctly programmed
    
51.     // real time application should not experience such a condition,
    
52.     // the table based mechanism is more efficient for real use. The
    
53.     // list based mechainsm is enabled by default since it is safer to
    
54.     // use during development.
    
55. 
    
56. #ifdef CYGIMP_KERNEL_INTERRUPTS_DSRS_TABLE
    
57.    
    
58.     static Cyg_Interrupt *dsr_table[CYGNUM_KERNEL_CPU_MAX]
    
59.                                    [CYGNUM_KERNEL_INTERRUPTS_DSRS_TABLE_SIZE]
    
60.                                    CYGBLD_ANNOTATE_VARIABLE_INTR;
    
61. 
    
62.     static cyg_ucount32 dsr_table_head[CYGNUM_KERNEL_CPU_MAX]
    
63.                                       CYGBLD_ANNOTATE_VARIABLE_INTR;
    
64. 
    
65.     static volatile cyg_ucount32 dsr_table_tail[CYGNUM_KERNEL_CPU_MAX]
    
66.                                                CYGBLD_ANNOTATE_VARIABLE_INTR;
    
67. 
    
68. #endif
    
69. #ifdef CYGIMP_KERNEL_INTERRUPTS_DSRS_LIST
    
70. 
    
71.     // Number of DSR posts made
    
72.     volatile cyg_ucount32 dsr_count CYGBLD_ANNOTATE_VARIABLE_INTR;
    
73. 
    
74.     // next DSR in list
    
75.     Cyg_Interrupt* volatile next_dsr CYGBLD_ANNOTATE_VARIABLE_INTR;
    
76. 
    
77.     // head of static list of pending DSRs
    
78.     static Cyg_Interrupt* volatile dsr_list[CYGNUM_KERNEL_CPU_MAX]
    
79.                                            CYGBLD_ANNOTATE_VARIABLE_INTR;
    
80. 
    
81. #  ifdef CYGSEM_KERNEL_INTERRUPTS_DSRS_LIST_FIFO
    
82.     // tail of static list of pending DSRs
    
83.     static Cyg_Interrupt* volatile dsr_list_tail[CYGNUM_KERNEL_CPU_MAX]
    
84.                                            CYGBLD_ANNOTATE_VARIABLE_INTR;
    
85. #  endif
    
86. 
    
87. #endif  // defined  CYGIMP_KERNEL_INTERRUPTS_DSRS_LIST
    
88. 
    
89. #ifdef CYGIMP_KERNEL_INTERRUPTS_CHAIN
    
90. 
    
91.     // The default mechanism for handling interrupts is to attach just
    
92.     // one Interrupt object to each vector. In some cases, and on some
    
93.     // hardware, this is not possible, and each vector must carry a chain
    
94.     // of interrupts.
    
95. 
    
96.     Cyg_Interrupt       *next;          // Next Interrupt in list
    
97. 
    
98.     // Chaining ISR inserted in HAL vector
    
99.     static cyg_uint32 chain_isr(cyg_vector vector, CYG_ADDRWORD data);   
    
100. 
     
101.     // Table of interrupt chains
     
102.     static Cyg_Interrupt *chain_list[CYGNUM_HAL_ISR_TABLE_SIZE];
     
103.    
     
104. #endif
     
105. 
     
106.     // Interrupt disable data. Interrupt disable can be nested. On
     
107.     // each CPU this is controlled by disable_counter[cpu]. When the
     
108.     // counter is first incremented from zero to one, the
     
109.     // interrupt_disable_spinlock is claimed using spin_intsave(), the
     
110.     // original interrupt enable state being saved in
     
111.     // interrupt_disable_state[cpu].  When the counter is decremented
     
112.     // back to zero the spinlock is cleared using clear_intsave().
     
113. 
     
114.     // The spinlock is necessary in SMP systems since a thread
     
115.     // accessing data shared with an ISR may be scheduled on a
     
116.     // different CPU to the one that handles the interrupt. So, merely
     
117.     // blocking local interrupts would be ineffective. SMP aware
     
118.     // device drivers should either use their own spinlocks to protect
     
119.     // data, or use the API supported by this class, via
     
120.     // cyg_drv_isr_lock()/_unlock(). Note that it now becomes
     
121.     // essential that ISRs do this if they are to be SMP-compatible.
     
122. 
     
123.     // In a single CPU system, this mechanism reduces to just
     
124.     // disabling/enabling interrupts.
     
125. 
     
126.     // Disable level counter. This counts the number of times
     
127.     // interrupts have been disabled.
     
128.     static volatile cyg_int32 disable_counter[CYGNUM_KERNEL_CPU_MAX]
     
129.                                               CYGBLD_ANNOTATE_VARIABLE_INTR;
     
130. 
     
131.     // Interrupt disable spinlock. This is claimed by any CPU that has
     
132.     // disabled interrupts via the Cyg_Interrupt API.
     
133.     static Cyg_SpinLock interrupt_disable_spinlock CYGBLD_ANNOTATE_VARIABLE_INTR;
     
134. 
     
135.     // Saved interrupt state. When each CPU first disables interrupts
     
136.     // the original state of the interrupts are saved here to be
     
137.     // restored later.
     
138.     static CYG_INTERRUPT_STATE interrupt_disable_state[CYGNUM_KERNEL_CPU_MAX]
     
139.                                                        CYGBLD_ANNOTATE_VARIABLE_INTR;
     
140. 
     
141.    
     
142. public:
     
143. 
     
144.     Cyg_Interrupt                       // Initialize interrupt
     
145.     (
     
146.         cyg_vector      vector,         // Vector to attach to
     
147.         cyg_priority    priority,       // Queue priority
     
148.         CYG_ADDRWORD    data,           // Data pointer
     
149.         cyg_ISR         *isr,           // Interrupt Service Routine
     
150.         cyg_DSR         *dsr            // Deferred Service Routine
     
151.         );
     
152. 
     
153.     ~Cyg_Interrupt();
     
154.         
     
155.     // ISR return values
     
156.     enum {
     
157.         HANDLED  = 1,                   // Interrupt was handled
     
158.         CALL_DSR = 2                    // Schedule DSR
     
159.     };
     
160. 
     
161.     // Interrupt management
     
162.         
     
163.     void        attach();               // Attach to vector
     
164. 
     
165. 
     
166.     void        detach();               // Detach from vector
     
167.         
     
168.    
     
169.     // Static Interrupt management functions
     
170. 
     
171.     // Get the current service routine
     
172.     static void get_vsr(cyg_vector vector, cyg_VSR **vsr);
     
173. 
     
174.     // Install a vector service routine
     
175.     static void set_vsr(
     
176.         cyg_vector vector,              // hardware vector to replace
     
177.         cyg_VSR *vsr,                   // my new service routine
     
178.         cyg_VSR **old = NULL            // pointer to old vsr, if required
     
179.         );
     
180. 
     
181. 
     
182.     // Static interrupt masking functions
     
183. 
     
184.     // Disable interrupts at the CPU
     
185.     static void disable_interrupts();
     
186. 
     
187.     // Re-enable CPU interrupts
     
188.     static void enable_interrupts();
     
189. 
     
190.     // Are interrupts enabled at the CPU?
     
191.     static inline cyg_bool interrupts_enabled()
     
192.     {
     
193.         return (0 == disable_counter[CYG_KERNEL_CPU_THIS()]);
     
194.     }
     
195.    
     
196.     // Get the vector for the following calls
     
197.     inline cyg_vector get_vector()
     
198.     {
     
199.         return vector;
     
200.     }
     
201.    
     
202.     // Static PIC control functions
     
203.    
     
204.     // Mask a specific interrupt in a PIC
     
205.     static void mask_interrupt(cyg_vector vector);
     
206.     // The same but not interrupt safe
     
207.     static void mask_interrupt_intunsafe(cyg_vector vector);
     
208. 
     
209.     // Clear PIC mask
     
210.     static void unmask_interrupt(cyg_vector vector);
     
211.     // The same but not interrupt safe
     
212.     static void unmask_interrupt_intunsafe(cyg_vector vector);
     
213. 
     
214.     // Acknowledge interrupt at PIC
     
215.     static void acknowledge_interrupt(cyg_vector vector);
     
216. 
     
217.     // Change interrupt detection at PIC
     
218.     static void configure_interrupt(
     
219.         cyg_vector vector,              // vector to control
     
220.         cyg_bool level,                 // level or edge triggered
     
221.         cyg_bool up                     // hi/lo level, rising/falling edge
     
222.         );
     
223. 
     
224. #ifdef CYGPKG_KERNEL_SMP_SUPPORT
     
225. 
     
226.     // SMP support for associating an interrupt with a specific CPU.
     
227.    
     
228.     static void set_cpu( cyg_vector, HAL_SMP_CPU_TYPE cpu );
     
229.     static HAL_SMP_CPU_TYPE get_cpu( cyg_vector );
     
230.    
     
231. #endif   
     
232. };

复制代码

这只是声明了这个class，这个class的构造/析构函数和成员函数的实现，还要找cyg/kernel/intr.hxx头文件相对应的C文件，
在这里....\packages\kernel\current\src\intr\intr.cxx找到了intr.cxx文件，因为cyg_interrupt_create函数实际上调用了class Cyg_Interrupt的构造函数，我们就来看看这个构造函数：

1. Cyg_Interrupt::Cyg_Interrupt(
   
2.     cyg_vector      vec,                // Vector to attach to
   
3.     cyg_priority    pri,                // Queue priority
   
4.     CYG_ADDRWORD    d,                  // Data pointer
   
5.     cyg_ISR         *ir,                // Interrupt Service Routine
   
6.     cyg_DSR         *dr                 // Deferred Service Routine
   
7.     )
   
8. {
   
9.     CYG_REPORT_FUNCTION();
   
10.     CYG_REPORT_FUNCARG5("vector=%d, priority=%d, data=%08x, isr=%08x, "
    
11.                         "dsr=%08x", vec, pri, d, ir, dr);
    
12.    
    
13.     vector      = vec;
    
14.     priority    = pri;
    
15.     isr         = ir;
    
16.     dsr         = dr;
    
17.     data        = d;
    
18. 
    
19. #ifdef CYGIMP_KERNEL_INTERRUPTS_DSRS_LIST
    
20. 
    
21.     dsr_count   = 0;
    
22.     next_dsr    = NULL;
    
23. 
    
24. #endif
    
25. 
    
26. #ifdef CYGIMP_KERNEL_INTERRUPTS_CHAIN
    
27. 
    
28.     next        = NULL;
    
29.    
    
30. #endif
    
31. 
    
32.     CYG_REPORT_RETURN();
    
33.    
    
34. };

复制代码

也就是分配了一下成员变量，把cyg_interrupt_create函数传进来的 中断号、ISR、DSR等 分配给类的成员变量，好像也没什么特别的。
看来整个cyg_interrupt_create函数也就是在构造这个类对象了。

这样重要的好戏是在cyg_interrupt_attach函数里完成了，看cyg_interrupt_attach的源代码，只一行，再次列出如下：

1. void cyg_interrupt_attach( cyg_handle_t interrupt ) __THROW
   
2. {
   
3.     ((Cyg_Interrupt *)interrupt)->attach();
   
4. }

复制代码

它也就是调用了class Cyg_Interrupt的attach成员函数，那我们到intr.cxx中看看attach这个成员函数都干了些啥？

1. // -------------------------------------------------------------------------
   
2. // Attach an ISR to an interrupt vector.
   
3. 
   
4. void
   
5. Cyg_Interrupt::attach(void)
   
6. {
   
7.     CYG_REPORT_FUNCTION();
   
8. 
   
9.     CYG_ASSERT( vector >= CYGNUM_HAL_ISR_MIN, "Invalid vector");
   
10.     CYG_ASSERT( vector <= CYGNUM_HAL_ISR_MAX, "Invalid vector");
    
11. 
    
12.     CYG_INSTRUMENT_INTR(ATTACH, vector, 0);
    
13. 
    
14.     HAL_INTERRUPT_SET_LEVEL( vector, priority );
    
15.    
    
16. #ifdef CYGIMP_KERNEL_INTERRUPTS_CHAIN
    
17. 
    
18.     CYG_ASSERT( next == NULL , "Cyg_Interrupt already on a list");
    
19. 
    
20.     cyg_uint32 index;
    
21. 
    
22.     HAL_TRANSLATE_VECTOR( vector, index );
    
23. 
    
24.     if( chain_list[index] == NULL )
    
25.     {
    
26.         int in_use CYGBLD_ATTRIB_UNUSED;
    
27.         // First Interrupt on this chain, just assign it and register
    
28.         // the chain_isr with the HAL.
    
29.         
    
30.         chain_list[index] = this;
    
31. 
    
32.         HAL_INTERRUPT_IN_USE( vector, in_use );
    
33.         CYG_ASSERT( 0 == in_use, "Interrupt vector not free.");
    
34.         HAL_INTERRUPT_ATTACH( vector, chain_isr, &chain_list[index], NULL );
    
35.     }
    
36.     else
    
37.     {
    
38.         // There are already interrupts chained, add this one into the
    
39.         // chain in priority order.
    
40.         
    
41.         Cyg_Interrupt **p = &chain_list[index];
    
42. 
    
43.         while( *p != NULL )
    
44.         {
    
45.             Cyg_Interrupt *n = *p;
    
46. 
    
47.             if( n->priority < priority ) break;
    
48.             
    
49.             p = &n->next;
    
50.         }
    
51.         next = *p;
    
52.         *p = this;
    
53.     }
    
54.    
    
55. #else
    
56.    
    
57.     {
    
58.         int in_use CYGBLD_ATTRIB_UNUSED;
    
59. 
    
60.         HAL_INTERRUPT_IN_USE( vector, in_use );
    
61.         CYG_ASSERT( 0 == in_use, "Interrupt vector not free.");
    
62. 
    
63.         HAL_INTERRUPT_ATTACH( vector, isr, data, this );
    
64.     }
    
65. 
    
66. #endif   
    
67.     CYG_REPORT_RETURN();
    
68. }

复制代码

attach成员函数又调用了 HAL_INTERRUPT_ATTACH 这个HAL层的宏，那就继续追踪这个宏吧， 它定义在里，如下：

1. #define HAL_INTERRUPT_ATTACH( _vector_, _isr_, _data_, _object_ )           \
   
2.     CYG_MACRO_START                                                         \
   
3.     cyg_uint32 _index_;                                                     \
   
4.     HAL_TRANSLATE_VECTOR( _vector_, _index_ );                              \
   
5.                                                                             \
   
6.     if( hal_interrupt_handlers[_index_] == (CYG_ADDRESS)HAL_DEFAULT_ISR )   \
   
7.     {                                                                       \
   
8.         hal_interrupt_handlers[_index_] = (CYG_ADDRESS)_isr_;               \
   
9.         hal_interrupt_data[_index_] = (CYG_ADDRWORD)_data_;                 \
   
10.         hal_interrupt_objects[_index_] = (CYG_ADDRESS)_object_;             \
    
11.     }                                                                       \
    
12.     CYG_MACRO_END

复制代码

注：CYG_MACRO_START 和 CYG_MACRO_END 宏定义在中：

1. #define CYG_MACRO_START do {
   
2. #define CYG_MACRO_END   } while (0)

复制代码

这个宏主要干了3件事：以中断号作为索引，将 isr地址、data 和 0bject地址(也就是class Cyg_Interrupt的对象) 3者分别存入hal_interrupt_handlers、hal_interrupt_data and hal_interrupt_objects 3个数组中。这3个数组定义在hal_intr.h头文件相对应的hal_intr.c 文件中，这个C文件也没干其他事，就只定义了这3个全局数组，如下：

1. // Create the interrupt handler table, with all handlers set to the 'safe'
   
2. // default.
   
3. 
   
4. volatile CYG_ADDRESS hal_interrupt_handlers[CYGNUM_HAL_ISR_COUNT] =
   
5. {(CYG_ADDRESS)HAL_DEFAULT_ISR,
   
6. (CYG_ADDRESS)HAL_DEFAULT_ISR,
   
7.              .
   
8.              .
   
9.              .
   
10.              .
    
11. (CYG_ADDRESS)HAL_DEFAULT_ISR,
    
12. (CYG_ADDRESS)HAL_DEFAULT_ISR};
    
13. 
    
14. volatile CYG_ADDRWORD   hal_interrupt_data[CYGNUM_HAL_ISR_COUNT];
    
15. volatile CYG_ADDRESS    hal_interrupt_objects[CYGNUM_HAL_ISR_COUNT];

复制代码

最关键的就是hal_interrupt_handlers数组，它放的就是所有终端ISR的地址。

但是，追踪到这个数组，好像也就追不下去了， 这样的一个ISR table，又是怎样被索引调用的呢？

我们只顾忙着追踪，应该回想一下，我们知道HAL层是ecos中和硬件结构相关的地址， 我们上面分析的部分HAL层代码实际上是具体于某一CPU架构的。 而我上面看的HAL代码就是NIOS II的HAL层，只是上面的一点HAL代码好像还看不出与CPU结构相关的特殊性。

那如果我们还要继续trace, 看来就必须要和CPU结构密切相关了，也能感觉的到是和硬件中断向量有关的东东， 那我们就以NIOS II为例继续追踪， 你会发现，和上面hal_intr.c文件同一目录下， ....\packages\hal\nios2\arch\current\src\ 有一个vector.S汇编文件，一看到它的名字，就有感觉，打开它，你会发现， 它分了4大块，分别定义了4种不同情况下，CPU发生异常or接收到中断时，要执行的代码，

1. /*
   
2.      * ========================================================================
   
3.      * _hardware_reset
   
4.      *
   
5.      * This is the reset entry point for Nios II.
   
6.      *
   
7.      * At reset, only the cache line which contain the reset vector is
   
8.      * initialized. Therefore the code within the first cache line is required
   
9.      * to initialize the instruction cache for the remainder of the code.
   
10.      *
    
11.      * Note that the automatically generated linker script requires that
    
12.      * the .init section is less than 0x20 bytes long.
    
13.      */
    
14. L106  _hardware_reset:
    
15. 
    
16. 
    
17.     /*
    
18.      * ========================================================================
    
19.      * _exception_vector
    
20.      *
    
21.      * This is the exception entry point. It is responsible for determing if the
    
22.      * exception was caused by an hardware interrupt, or a software exception.
    
23.      * It then vectors accordingly using the VSR table to handle the exception.
    
24.      */
    
25. L283  _exception_vector:
    
26. 
    
27. 
    
28.     /*
    
29.      * ========================================================================
    
30.      * _interrupt_handler
    
31.      *
    
32.      * This is the default handler for hardware interrupts.
    
33.      */
    
34. L342  _interrupt_handler::
    
35. 
    
36.     /*
    
37.      * ========================================================================
    
38.      * _software_exception_handler
    
39.      *
    
40.      * This is the default handler for software exceptions.
    
41.      */
    
42. 
    
43.     .globl _software_exception_handler
    
44.     .type _software_exception_handler, @function
    
45. 
    
46. L613  _software_exception_handler:
    
47. 
    
48. 顾名思义，我们要找的应该在_interrupt_handler中，果不其然，其中有如下一段代码:
    
49. 
    
50. L465    /*
    
51.          * Having located the interrupt source, r4 contains the index of the
    
52.          * interrupt to be handled.
    
53.          *
    
54.          * This is converted into an offset into the handler table,
    
55.          * and stored in r15.
    
56.          */
    
57.    
    
58.         slli r15, r4, 2
    
59.         
    
60. L475    /*
    
61.          * Load into r1 the address of the handler for this interrupt. This is
    
62.          * obtained from the interrupt handler table: hal_interrupt_handlers.
    
63.          */
    
64.    
    
65.         movhi r1, %hiadj(hal_interrupt_handlers)
    
66.         addi r1, r1, %lo(hal_interrupt_handlers)
    
67.         add r1, r1, r15
    
68.         ldw r1, (r1)
    
69.    
    
70.         /*
    
71.          * Load into r5 the data associated with the interrupt handler. This is
    
72.          * obtained from the table: hal_interrupt_data.
    
73.          */
    
74.    
    
75.         movhi r5, %hiadj(hal_interrupt_data)
    
76.         addi r5, r5, %lo(hal_interrupt_data)
    
77.         add r5, r5, r15
    
78.         ldw r5, (r5)
    
79.    
    
80.         /*
    
81.          * Call the interrupt handler  The input arguments are the interrupt number
    
82.          * and the associated data obtained above. Save off r15 explicitly since
    
83.          * its a caller-saved register and is used below.
    
84.          */
    
85.         addi sp, sp, -4
    
86.         stw r15, (sp)
    
87. L502    callr r1
    
88.         ldw r15, (sp)
    
89. L504    addi sp, sp, 4

复制代码

你看，r4中存有要相应的中断号，它又存入r15中，根据r15的值， 在hal_interrupt_handlers数组中得到相应的ISR地址存入r1中， 在L502行callr r1，就调用了中断ISR。

至此，层层追踪结束，大功告成。 终于搞明白了ecos中ISR是怎么响应到硬件中断事件的。 其实，剥茧抽丝，层层追踪，兜兜转转，你会发现class Cyg_Interrupt这个C++类，只是做了一个高层的包装，
真正起作用的还是底层HAL相关的代码。