packages/hal/h8300/arch/v2_0/src/vectors.S

   1 ##=============================================================================
   2 ##
   3 ##      vectors.S
   4 ##
   5 ##      H8/300 exception vectors
   6 ##
   7 ##=============================================================================
   8 #####ECOSGPLCOPYRIGHTBEGIN####
   9 ## -------------------------------------------
  10 ## This file is part of eCos, the Embedded Configurable Operating System.
  11 ## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
  12 ##
  13 ## eCos is free software; you can redistribute it and/or modify it under
  14 ## the terms of the GNU General Public License as published by the Free
  15 ## Software Foundation; either version 2 or (at your option) any later version.
  16 ##
  17 ## eCos is distributed in the hope that it will be useful, but WITHOUT ANY
  18 ## WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19 ## FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20 ## for more details.
  21 ##
  22 ## You should have received a copy of the GNU General Public License along
  23 ## with eCos; if not, write to the Free Software Foundation, Inc.,
  24 ## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  25 ##
  26 ## As a special exception, if other files instantiate templates or use macros
  27 ## or inline functions from this file, or you compile this file and link it
  28 ## with other works to produce a work based on this file, this file does not
  29 ## by itself cause the resulting work to be covered by the GNU General Public
  30 ## License. However the source code for this file must still be made available
  31 ## in accordance with section (3) of the GNU General Public License.
  32 ##
  33 ## This exception does not invalidate any other reasons why a work based on
  34 ## this file might be covered by the GNU General Public License.
  35 ##
  36 ## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
  37 ## at http://sources.redhat.com/ecos/ecos-license/
  38 ## -------------------------------------------
  39 #####ECOSGPLCOPYRIGHTEND####
  40 ##=============================================================================
  41 #######DESCRIPTIONBEGIN####
  42 ##
  43 ## Author(s):   Yoshinori Sato
  44 ## Contributors: Yoshinori Sato
  45 ## Date:        2002-02-14
  46 ## Purpose:     H8/300 exception vectors
  47 ## Description: This file defines the code placed into the exception
  48 ##              vectors. It also contains the first level default VSRs
  49 ##              that save and restore state for both exceptions and
  50 ##              interrupts.
  51 ##
  52 ######DESCRIPTIONEND####
  53 ##
  54 ##=============================================================================
  55
  56 #include <pkgconf/hal.h>
  57
  58 #ifdef CYGPKG_REDBOOT
  59 #include <pkgconf/redboot.h>
  60 #endif
  61
  62 #ifdef CYGPKG_KERNEL
  63
  64 #include <pkgconf/kernel.h>
  65
  66 #endif
  67
  68 #include <cyg/hal/arch.inc>
  69 #include <cyg/hal/basetype.h>
  70 #include <cyg/hal/variant.inc>
  71
  72
  73 ##-----------------------------------------------------------------------------
  74
  75 #ifdef CYGPKG_HAL_H8300_H8300H
  76         .h8300h
  77         .macro  shll2 reg
  78         shll.l  \reg
  79         shll.l  \reg
  80         .endm
  81         .macro  shlr2 reg
  82         shlr.l  \reg
  83         shlr.l  \reg
  84         .endm
  85 #endif
  86 #ifdef CYGPKG_HAL_H8300_H8S
  87         .h8300s
  88         .macro  shll2 reg
  89         shll.l  #2,\reg
  90         .endm
  91         .macro  shlr2 reg
  92         shlr.l  #2,\reg
  93         .endm
  94 #endif
  95
  96 #ifdef CYGPKG_CYGMON
  97 ##-----------------------------------------------------------------------------
  98 ## Macros for Stack handling when running Cygmon
  99
 100 .macro hal_cygmon_switch_app_stack
 101 #ifdef CYGPKG_HAL_H8300_H8300H
 102         ; Switch to interrupt stack to handle exception
 103
 104         ; First, save some scratch registers
 105         mov.l   er0,@-sp
 106         mov.l   er1,@-sp
 107
 108         ; Copy the exception frame
 109         mov.l   #__cygmon_interrupt_stack,er0
 110         mov.l   @(8:16,sp),er1
 111         mov.l   er1,@-er0
 112
 113         ; Save the pre-exception sp in the register image
 114         mov.l   sp,@-er0
 115
 116         ; Actually switch the stack
 117         mov.l   er0,sp
 118
 119         mov.l   @sp,er0
 120         adds    #4,er0
 121         adds    #4,er0
 122         mov.l   er0,@sp
 123
 124         ; Now, restore the scratch registers
 125         mov.l   @(-4:16,er0),er1
 126         mov.l   @(-8:16,er0),er0
 127 #endif
 128 #ifdef CYGPKG_HAL_H8300_H8S
 129         ; Switch to interrupt stack to handle exception
 130
 131         ; First, save some scratch registers
 132         stm.l   er0-er1,@-sp
 133
 134         ; Copy the exception frame
 135         mov.l   #__cygmon_interrupt_stack,er0
 136         mov.l   @(10,sp:16),er1
 137         mov.l   er1,@-er0
 138         mov.w   @(10,sp:16),r1
 139         mov.w   r1,@-er0
 140
 141         ; Save the pre-exception sp in the register image
 142         mov.l   sp,@-er0
 143
 144         ; Actually switch the stack
 145         mov.l   er0,sp
 146
 147         mov.l   @sp,er0
 148         adds    #4,er0
 149         adds    #4,er0
 150         mov.l   er0,@sp
 151
 152         ; Now, restore the scratch registers
 153         mov.l   @(-4:16,er0),er1
 154         mov.l   @(-8:16,er0),er0
 155 #endif
 156 .endm
 157
 158 .macro hal_cygmon_restore_app_stack
 159         // For cygmon we are switching stacks immediately on exception.
 160         // We must wait until the very end before restoring the original stack.
 161
 162 #ifdef CYGPKG_HAL_H8300_H8300H
 163         ; Save some scratch registers
 164         subs    #4,sp
 165         mov.l   er0,@-sp
 166         mov.l   er1,@-sp
 167
 168         ; We need to restore the application stack pointer, but we also
 169         ; need to restore the exception frame.
 170         mov.l   @(12:16,sp),er0
 171         mov.l   @(16:16,sp),er1
 172         mov.l   er1,@er0
 173         mov.l   er0,@(8:16,sp)
 174
 175         ; Restore the scratch registers
 176         mov.l   @sp+,er1
 177         mov.l   @sp+,er0
 178         mov.l   @sp+,sp                 // Restore the frame-adjusted SP
 179 #endif
 180 #ifdef CYGPKG_HAL_H8300_H8S
 181         ; Save some scratch registers
 182         subs    #4,sp
 183         stm.l   er0-er1,@-sp
 184
 185         ; We need to restore the application stack pointer, but we also
 186         ; need to restore the exception frame.
 187         mov.l   @(12:16,sp),er0
 188         mov.w   @(16:16,sp),r1
 189         mov.w   r1,@er0
 190         mov.l   @(18:16,sp),er1
 191         mov.l   er1,@er0
 192         mov.l   er0,@(8:16,sp)
 193
 194         ; Restore the scratch registers
 195         ldm.l   @sp+,er0-er1
 196         mov.l   @sp+,sp                 // Restore the frame-adjusted SP
 197 #endif
 198 .endm
 199
 200 #endif // CYGPKG_CYGMON
 201
 202 ##-----------------------------------------------------------------------------
 203
 204 #if (defined(CYG_HAL_STARTUP_ROM) || \
 205      defined(CYGPKG_HAL_H8300_H8300H_SIM) || \
 206      defined(CYGPKG_HAL_H8300_H8S_SIM))
 207
 208         .section .vectors,"a"
 209
 210         .globl  reset_vector
 211
 212 reset_vector:
 213         .long   CYG_LABEL_DEFN(_start)
 214         .long   CYG_LABEL_DEFN(_start)
 215 vector  =       2
 216         .rept   CYG_ISR_TABLE_SIZE-2
 217         .long   interrupt_redirect_table+vector*4
 218 vector  =       vector + 1
 219         .endr
 220 #endif
 221
 222 #if !defined(CYGSEM_HAL_H8300_VECTOR_HOOK)
 223         .section .int_hook_table,"ax"
 224 interrupt_redirect_table:
 225 vector  =       0
 226         .rept   CYG_ISR_TABLE_SIZE
 227         jsr     @interrupt_entry
 228 vector  =       vector + 1
 229         .endr
 230 #else
 231         .section .int_hook_table,"x"
 232 interrupt_redirect_table:
 233         .space  4*CYG_ISR_TABLE_SIZE
 234 #endif
 235
 236 ##-----------------------------------------------------------------------------
 237 ## Startup code
 238
 239         .text
 240
 241         .globl  CYG_LABEL_DEFN(_start)
 242 CYG_LABEL_DEFN(_start):
 243         ; set up stack
 244
 245         mov.l   #__interrupt_stack,sp
 246
 247         ; Initialize hardware
 248         hal_cpu_init
 249         hal_mmu_init
 250         hal_memc_init
 251         hal_diag_init
 252         hal_intc_init
 253         hal_cache_init
 254         hal_timer_init
 255         hal_mon_init
 256
 257 #ifdef CYG_HAL_STARTUP_ROM
 258
 259         ; Copy data from ROM to RAM
 260
 261         mov.l   #CYG_LABEL_DEFN(__rom_data_start),er5
 262         mov.l   #CYG_LABEL_DEFN(__ram_data_start),er6
 263         mov.l   #CYG_LABEL_DEFN(__ram_data_end),er4
 264         sub.l   er6,er4
 265         shlr2   er4
 266 1:
 267         mov.l   @er5+,er0
 268         mov.l   er0,@er6
 269         adds    #4,er6
 270         dec.l   #1,er4
 271         bne     1b
 272
 273 #endif
 274
 275 #if defined(CYGSEM_HAL_H8300_VECTOR_HOOK)
 276         ; Setup Interrupt Vector (virtual)
 277
 278         ;; check rom table
 279         mov.l   #8*4,er0
 280         mov.l   @er0+,er1
 281         adds    #4,er1
 282         mov.b   #3,r3l
 283 1:
 284         mov.l   @er0+,er2
 285         cmp.l   er1,er2
 286         bne     3f
 287         adds    #4,er1
 288         dec.b   r3l
 289         bne     1b
 290         ;; calculate vector address
 291         mov.l   @8*4,er0
 292         and.w   #0xff,e0
 293         sub.l   #8*4,er0
 294         ;; build ram vector
 295         mov.l   er0,@__interrupt_table
 296         mov.l   #0x5e000000+interrupt_entry,er1
 297         mov.l   #save_vector_table,er3
 298         mov.b   #0,r2l
 299 2:
 300         ;; check saved vector
 301         mov.b   @er3+,r2h
 302         cmp.b   r2l,r2h
 303         beq     5f
 304         subs    #1,er3
 305         mov.l   er1,@er0
 306 5:
 307         adds    #4,er0
 308         inc.b   r2l
 309         cmp.b   #CYG_ISR_TABLE_SIZE,r2l
 310         bcs     2b
 311         bra     4f
 312 3:
 313         bra     3b
 314 4:
 315
 316 #else
 317         mov.l   #interrupt_redirect_table,er0
 318         mov.l   er0,@__interrupt_table
 319 #endif
 320
 321         ; Clear BSS
 322         mov.l   #CYG_LABEL_DEFN(__bss_start),er5
 323         mov.l   #CYG_LABEL_DEFN(__bss_end),er4
 324         sub.l   #CYG_LABEL_DEFN(__bss_start),er4
 325         shlr2   er4
 326         sub.l   er0,er0
 327 1:
 328         mov.l   er0,@er5
 329         adds    #4,er5
 330         dec.l   #1,er4
 331         bne     1b
 332
 333         ; Call variant and platform HAL
 334         ; initialization routines.
 335
 336         .extern CYG_LABEL_DEFN(hal_variant_init)
 337         jsr     @CYG_LABEL_DEFN(hal_variant_init)
 338
 339         .extern CYG_LABEL_DEFN(hal_platform_init)
 340         jsr     @CYG_LABEL_DEFN(hal_platform_init)
 341
 342         ; Call constructors
 343
 344         .extern CYG_LABEL_DEFN(cyg_hal_invoke_constructors)
 345         jsr     @CYG_LABEL_DEFN(cyg_hal_invoke_constructors)
 346
 347 #ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS
 348         .extern CYG_LABEL_DEFN(initialize_stub)
 349         jsr     @CYG_LABEL_DEFN(initialize_stub)
 350 #endif
 351
 352 #if defined(CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT) \
 353     || defined(CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT)
 354         .extern CYG_LABEL_DEFN(hal_ctrlc_isr_init)
 355         jsr     @CYG_LABEL_DEFN(hal_ctrlc_isr_init)
 356 #endif
 357
 358
 359         ; Call cyg_start
 360         sub.l   er0,er0
 361
 362         .extern CYG_LABEL_DEFN(cyg_start)
 363         jsr     @CYG_LABEL_DEFN(cyg_start)
 364
 365 9:
 366         bra     9b              ; Loop if we return
 367
 368 save_vector_table:
 369 #if defined(CYGSEM_HAL_H8300_SAVE_STUB_VECTOR)
 370         .byte   5,11
 371 #if defined(CYGPKG_HAL_H8300_SAVED_VECTORS)
 372         h8300_save_vectors
 373 #endif
 374 #endif
 375         .byte   0               ; end maker
 376         .align  2
 377
 378 interrupt_entry:
 379         mov.l   er0,@-sp
 380         mov.l   @(4:16,sp),er0  ; interrupt vector offset
 381         mov.l   er1,@-sp
 382         mov.l   @__interrupt_table,er1
 383         sub.l   er1,er0
 384         shlr2   er0
 385         dec.l   #1,er0
 386         mov.l   er0,@CYG_LABEL_DEFN(_intvector)
 387         mov.l   @sp+,er1
 388         mov.l   @sp+,er0
 389         adds    #4,sp
 390 #ifdef CYGPKG_CYGMON
 391         hal_cygmon_switch_app_stack
 392 #endif
 393         hal_cpu_save_all
 394         h8300_var_interrupt_entry               ; load isr address
 395         jmp     @er0
 396
 397 ##-----------------------------------------------------------------------------
 398 ## The following macros are defined depending on whether the HAL is configured
 399 ## to support the kernel or not.
 400
 401 #ifdef CYGFUN_HAL_COMMON_KERNEL_SUPPORT
 402
 403         .extern CYG_LABEL_DEFN(cyg_scheduler_sched_lock)
 404
 405         ; Increment the scheduler lock
 406
 407         .macro increment_sched_lock reg=er0
 408         mov.l   @CYG_LABEL_DEFN(cyg_scheduler_sched_lock),\reg
 409         inc.l   #1,\reg
 410         mov.l   \reg,@CYG_LABEL_DEFN(cyg_scheduler_sched_lock)
 411         .endm
 412
 413 #else
 414
 415         .macro increment_sched_lock reg=er0
 416         .endm
 417
 418 #endif
 419
 420 ##-----------------------------------------------------------------------------
 421 ## Default interrupt VSR
 422
 423         .text
 424         .globl  CYG_LABEL_DEFN(__default_interrupt_vsr)
 425 CYG_LABEL_DEFN(__default_interrupt_vsr):
 426
 427         ; We come here with all the registers pushed
 428         ; onto the stack.
 429
 430         hal_diag_intr_start
 431
 432         increment_sched_lock
 433
 434 #if defined(CYGPKG_CYGMON)
 435         // For Cygmon, we saved this back when we originally switched stacks.
 436         mov.l   sp,er1                          ; A2 = saved thread state
 437 #elif defined(CYGIMP_HAL_COMMON_INTERRUPTS_USE_INTERRUPT_STACK)
 438         ; Increment interrupt nesting counter
 439         mov.l   sp,er1
 440         mov.l   #__interrupt_stack,er0          ; A0 = interrupt stack top
 441         cmp.l   #__interrupt_stack_base,sp      ; compare with base of stack
 442         blt     1f                              ; if lt switch to int stack
 443         cmp.l   er0,sp                          ; compare sp with stack top
 444         ble     8f                              ; if le already on istack
 445 1:
 446         mov.l   er0,sp                          ; switch to new SP
 447 8:
 448         mov.l   er1,@-sp                        ; save old SP
 449
 450 #else
 451         mov     sp,er1                          ; A2 = saved thread state
 452 #endif
 453         mov.l   er1,er4
 454
 455         ; Here D3 contains the table byte offset of the vector to
 456         ; call.
 457
 458 #if defined(CYGPKG_KERNEL_INSTRUMENT) && defined(CYGDBG_KERNEL_INSTRUMENT_INTR)
 459
 460         ; Call cyg_instrument to record that this interrupt is being raised.
 461
 462         .extern CYG_LABEL_DEFN(cyg_instrument)
 463         mov.l   #0x0301,er0                     ; type = INTR,RAISE
 464         mov.l   @CYG_LABEL_DEFN(_intvector),er2         ; arg2 = table offset
 465         jsr     CYG_LABEL_DEFN(cyg_instrument)  ; call instrumentation
 466
 467 #endif
 468
 469 #ifdef CYGSEM_HAL_COMMON_INTERRUPTS_ALLOW_NESTING
 470
 471         ; To allow nested interrupts, we set the IE bit. We do
 472         ; not touch the IPL bits, so only higher priority interrupts
 473         ; will be nested on top of us. Also, new interrupts will not
 474         ; be delivered until the ISR calls
 475         ; Cyg_Interrupt::acknowledge_interrupt(). At some future point
 476         ; we may want to do the ack stuff here to allow immediate nesting.
 477
 478         mov.l   @CYG_LABEL_DEFN(_intvector),er0
 479         mov.b   @(CYG_LABEL_DEFN(cyg_hal_level_table),er0),r0l
 480         hal_cpu_set_int_level
 481 #endif
 482 #if defined(CYGDBG_HAL_DEBUG_GDB_CTRLC_SUPPORT) || \
 483     defined(CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT)
 484
 485         ; If we have Ctrl-C support enabled, save a pointer to the
 486         ; saved CPU state here so we can plant a breakpoint there if
 487         ; this is a ^C.
 488
 489         .extern CYG_LABEL_DEFN(hal_saved_interrupt_state)
 490         mov.l   er4,@CYG_LABEL_DEFN(hal_saved_interrupt_state)
 491
 492 #endif
 493         mov.l   @CYG_LABEL_DEFN(_intvector),er0
 494         shll2   er0
 495         mov.l   @(CYG_LABEL_DEFN(hal_interrupt_handlers),er0),er2
 496
 497         mov.l   @(CYG_LABEL_DEFN(hal_interrupt_data),er0),er1
 498
 499         shlr2   er0
 500
 501         jsr     @er2
 502
 503         ; on return d0 bit 1 will indicate whether a DSR is
 504         ; to be posted. Pass this together with a pointer to
 505         ; the interrupt object we have just used to the
 506         ; interrupt tidy up routine.
 507
 508         ; D3 is defined to be saved across procedure calls, and
 509         ; should still contain the vector byte index. Similarly,
 510         ; A2 should still point to the saved machine state.
 511
 512 #ifdef CYGDBG_HAL_DEBUG_GDB_BREAK_SUPPORT
 513         ; If interrupt was caused by GDB, the ISR call above
 514         ; is skipped by jumping here.
 515 2:
 516 #endif
 517
 518 #if defined(CYGIMP_HAL_COMMON_INTERRUPTS_USE_INTERRUPT_STACK) && !defined(CYGPKG_CYGMON)
 519
 520         ; If we are returning from the last nested interrupt, move back
 521         ; to the thread stack. interrupt_end() must be called on the
 522         ; thread stack since it potentially causes a context switch.
 523
 524         mov.l   @sp+,sp                         ; pop old sp
 525
 526 #endif
 527
 528 #ifdef CYGFUN_HAL_COMMON_KERNEL_SUPPORT
 529
 530         ; We only need to call _interrupt_end() when there is a kernel
 531         ; present to do any tidying up.
 532
 533         ; Using the vector offset in D3, get the interrupt object pointer
 534         ; into D1.
 535         mov.l   @CYG_LABEL_DEFN(_intvector),er1
 536         shll2   er1
 537         mov.l   @(CYG_LABEL_DEFN(hal_interrupt_objects),er1),er1
 538
 539         ; Even when this is not the last nested interrupt, we must call
 540         ; _interrupt_end() to post the DSR and decrement the scheduler
 541         ; lock.
 542
 543         mov.l   er3,er2                         ; arg3 = saved state.
 544
 545         jsr     @CYG_LABEL_DEFN(interrupt_end)  ; call interrupt end fn
 546 #endif
 547
 548
 549 #       show_interrupts
 550
 551         hal_diag_restore
 552
 553         hal_cpu_load_all
 554 #ifdef CYGPKG_CYGMON
 555         hal_cygmon_restore_app_stack
 556 #endif
 557         mov.l   er0,@-sp
 558         mov.l   @(4:16,sp),er0
 559         mov.l   er0,@__lastpc
 560         mov.l   @sp+,er0
 561
 562         rte                                     ; and return
 563
 564         .section        .bss
 565         .global CYG_LABEL_DEFN(_intvector)
 566 CYG_LABEL_DEFN(_intvector):
 567         .long   0
 568         .global __lastpc
 569 __lastpc:
 570         .long   0
 571 __interrupt_table:
 572         .long   0
 573
 574         .text
 575 ##-----------------------------------------------------------------------------
 576 ## Execute pending DSRs on the interrupt stack with interrupts enabled.
 577 ## Note: this can only be called from code running on a thread stack
 578
 579 #ifdef CYGIMP_HAL_COMMON_INTERRUPTS_USE_INTERRUPT_STACK
 580         .extern CYG_LABEL_DEFN(cyg_interrupt_call_pending_DSRs)
 581         .global CYG_LABEL_DEFN(hal_interrupt_stack_call_pending_DSRs)
 582
 583 CYG_LABEL_DEFN(hal_interrupt_stack_call_pending_DSRs):
 584         h8300_var_call_pending_DSR
 585 #endif
 586
 587 ##-----------------------------------------------------------------------------
 588 ## Default TRAP VSR
 589
 590         .text
 591         .globl  CYG_LABEL_DEFN(__default_trap_vsr)
 592 CYG_LABEL_DEFN(__default_trap_vsr):
 593
 594 #ifdef CYG_HAL_DIAG_EXCPT_END
 595         hal_diag_excpt_start
 596 #endif
 597         mov.l   @CYG_LABEL_DEFN(_intvector),er1
 598         cmp.l   #11,er1         ; Adjust trap entry address
 599         bne     1f
 600         h8300_trap_adjust_pc
 601 1:
 602         mov.l   sp,er0
 603         jsr     @CYG_LABEL_DEFN(cyg_hal_exception_handler)
 604
 605 #ifdef CYG_HAL_DIAG_EXCPT_END
 606         hal_diag_excpt_end
 607 #endif
 608         hal_cpu_load_all
 609 #ifdef CYGPKG_CYGMON
 610         hal_cygmon_restore_app_stack
 611 #endif
 612         rte
 613
 614 ##-----------------------------------------------------------------------------
 615 ## VSR table. The VSRs pointed to by this table are called from the stubs
 616 ## connected to the hardware.
 617
 618 #ifndef CYG_HAL_H8300_VSR_TABLE_DEFINED
 619
 620         .data
 621
 622         .globl  CYG_LABEL_DEFN(hal_vsr_table)
 623 CYG_LABEL_DEFN(hal_vsr_table):
 624         .long   CYG_LABEL_DEFN(__default_trap_vsr)
 625         .long   CYG_LABEL_DEFN(__default_trap_vsr)
 626         .long   0
 627         .long   0
 628         .long   0
 629         .long   CYG_LABEL_DEFN(__default_trap_vsr)
 630         .long   CYG_LABEL_DEFN(__default_trap_vsr)
 631         .long   CYG_LABEL_DEFN(__default_trap_vsr)
 632         .long   CYG_LABEL_DEFN(__default_trap_vsr)
 633         .long   CYG_LABEL_DEFN(__default_trap_vsr)
 634         .long   CYG_LABEL_DEFN(__default_trap_vsr)
 635         .long   CYG_LABEL_DEFN(__default_trap_vsr)
 636
 637         .rept   CYG_ISR_TABLE_SIZE-12
 638         .long   CYG_LABEL_DEFN(__default_interrupt_vsr)
 639         .endr
 640 #endif
 641
 642 ##-----------------------------------------------------------------------------
 643 ## Interrupt tables
 644
 645         .data
 646
 647         .extern CYG_LABEL_DEFN(hal_default_isr)
 648
 649         .globl  CYG_LABEL_DEFN(hal_interrupt_handlers)
 650 CYG_LABEL_DEFN(hal_interrupt_handlers):
 651         .rept   CYG_ISR_TABLE_SIZE
 652         .long   CYG_LABEL_DEFN(hal_default_isr)
 653         .endr
 654
 655         .globl  CYG_LABEL_DEFN(hal_interrupt_data)
 656 CYG_LABEL_DEFN(hal_interrupt_data):
 657         .rept   CYG_ISR_TABLE_SIZE
 658         .long   0
 659         .endr
 660
 661         .globl  CYG_LABEL_DEFN(hal_interrupt_objects)
 662 CYG_LABEL_DEFN(hal_interrupt_objects):
 663         .rept   CYG_ISR_TABLE_SIZE
 664         .long   0
 665         .endr
 666
 667
 668 ##-----------------------------------------------------------------------------
 669 ## Temporary interrupt stack
 670
 671         .section        .bss
 672
 673         .balign 2
 674         .global _cyg_interrupt_stack_base
 675 _cyg_interrupt_stack_base:
 676 __interrupt_stack_base:
 677         .rept CYGNUM_HAL_COMMON_INTERRUPTS_STACK_SIZE
 678         .byte 0
 679         .endr
 680         .balign 2
 681         .global _cyg_interrupt_stack
 682 _cyg_interrupt_stack:
 683 __interrupt_stack:
 684
 685 #ifdef CYGPKG_CYGMON
 686         .balign 2
 687         .global __cygmon_interrupt_stack_base
 688 __cygmon_interrupt_stack_base:
 689         .rept CYGNUM_HAL_COMMON_INTERRUPTS_STACK_SIZE
 690         .byte 0
 691         .endr
 692         .balign 2
 693         .global __cygmon_interrupt_stack
 694 __cygmon_interrupt_stack:
 695 #endif
 696
 697         .long   0,0,0,0,0,0,0,0
 698
 699 ##-----------------------------------------------------------------------------
 700
 701         .data
 702         hal_diag_data
 703
 704
 705 ##-----------------------------------------------------------------------------
 706 ## end of vectors.S
 707