tct.s

The neclus source code

        BX      lr                          ; Return to caller
        |	
        MOV     pc,lr                       ; Return to caller
        ]
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Build_Signal_Frame                                           */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function builds a frame on top of the task's stack to       */
;/*      cause the task's signal handler to execute the next time         */
;/*      the task is executed.                                            */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      TCC_Send_Signals                    Send signals to a task       */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      task                                Task control block pointer   */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      W. Lamie        02-15-1994      Created initial version 1.0      */
;/*      D. Lamie        02-15-1994      Verified version 1.0             */
;/*                                                                       */
;/*************************************************************************/
;VOID  TCT_Build_Signal_Frame(TC_TCB *task)
;{
        EXPORT  TCT_Build_Signal_Frame
TCT_Build_Signal_Frame
;
;    /* Pickup the stack pointer.  */
;    REG_Stack_Ptr =  (BYTE_PTR) task -> tc_stack_pointer;
;    
        LDR     a4,[a1,#&2c]                ; Pickup the current stack pointer
;
;    /* Reference the Signal shell.  */
;    REG_Function_Ptr =  (VOID *) TCC_Signal_Shell;
;
;    /* Build a signal stack.  This signal stack frame facilitates an 
;       solicited return to the TCC_Signal_Shell function, which in turn 
;       invokes the appropriate signal handler.  The initial HISR stack frame 
;       has the following format:
;
;               (Lower Address) Stack Top ->    0       (Solicited stack type)
;                !!FOR THUMB ONLY!!             0/0x20  Saved state mask
;                                               v1      Saved v1
;                                               v2      Saved v2
;                                               v3      Saved v3
;                                               v4      Saved v4
;                                               v5      Saved v5
;                                               v6/sb   Saved v6/sl
;                                               v7/sl   Saved v7/sl
;                                               fp      Saved fp
;                                               ip      Saved ip
;               (Higher Address) Stack Bottom-> pc      Saved pc
;    */
;
        LDR     a3,Signal_Shell             ; Pickup address of shell entry
        [ THUMB
        BIC     a3,a3,#1                    ; Clear low bit
        ]
        STR     a3,[a4], #-4                ; Store entry address on stack
        ADD     a3,a4,#&4                   ; Compute initial sp
        STR     a3,[a4], #-4                ; Store initial ip
        STR     a3,[a4], #-4                ; Store initial fp
        LDR     a3,[a1,#&24]                ; Pickup the stack starting address
        STR     a3,[a4], #-4                ; Store initial v7/sl
        MOV     a3,#0                       ; Clear value for initial registers
        STR     a3,[a4], #-4                ; Store initial v6/sb
        STR     a3,[a4], #-4                ; Store initial v5
        STR     a3,[a4], #-4                ; Store initial v4
        STR     a3,[a4], #-4                ; Store initial v3
        STR     a3,[a4], #-4                ; Store initial v2
        STR     a3,[a4], #-4                ; Store initial v1
        [ THUMB
        MOV     a2,#&20                     ; Get initial state mask
    	STR     a2,[a4], #-4                ; Store initial state mask  
        ]
        STR     a3,[a4, #0]                 ; Store solicited stack type on the
                                            ; top of the stack 
;
;    /* Save the new stack pointer into the task's control block.  */
;    task -> tc_stack_pointer =  (VOID *) (REG_Stack_Ptr - REG_Stack_Size);
;
        STR     a4,[a1, #&2C]               ; Save stack pointer

        [ THUMB
        BX      lr                          ; Return to caller
        |	
        MOV     pc,lr                       ; Return to caller
        ]
;}
;
;
;
;/*************************************************************************/
;/*                                                                       */
;/* FUNCTION                                                              */
;/*                                                                       */
;/*      TCT_Check_Stack                                                  */
;/*                                                                       */
;/* DESCRIPTION                                                           */
;/*                                                                       */
;/*      This function checks the current stack for overflow conditions.  */
;/*      Additionally, this function keeps track of the minimum amount    */
;/*      of stack space for the calling thread and returns the current    */
;/*      available stack space.                                           */
;/*                                                                       */
;/* CALLED BY                                                             */
;/*                                                                       */
;/*      TCC_Send_Signals                    Send signals to a task       */
;/*                                                                       */
;/* CALLS                                                                 */
;/*                                                                       */
;/*      ERC_System_Error                    System error handler         */
;/*                                                                       */
;/* INPUTS                                                                */
;/*                                                                       */
;/*      None                                                             */
;/*                                                                       */
;/* OUTPUTS                                                               */
;/*                                                                       */
;/*      available bytes in stack                                         */
;/*                                                                       */
;/* HISTORY                                                               */
;/*                                                                       */
;/*         NAME            DATE                    REMARKS               */
;/*                                                                       */
;/*      W. Lamie        02-15-1994      Created initial version 1.0      */
;/*      D. Lamie        02-15-1994      Verified version 1.0             */
;/*                                                                       */
;/*************************************************************************/
;UNSIGNED  TCT_Check_Stack(void)
;{
        EXPORT  TCT_Check_Stack
TCT_Check_Stack
;
;TC_TCB         *thread;
;UNSIGNED       remaining;
;
;    /* Pickup the current task/HISR pointer.  */
;    thread =  (TC_TCB *) TCD_Current_Thread;
;
        LDR     a1,Current_Thread           ; Pickup address of thread pointer
        LDR     a1,[a1,#0]                  ; Pickup thread pointer
;
;    /* Determine if there is a current thread.  */
;    if (thread)
;    {
;
        CMP     a1,#0                       ; Determine if a thread is active
        MOV     a4,#0                       ; Default remaining value
        BEQ     TCT_Skip_Stack_Check        ; If NU_NULL, skip stack checking
;
;        /* Determine if the stack pointers are out of range.  */
;        if ((thread -> tc_stack_pointer < thread -> tc_stack_start) ||
;            (thread -> tc_stack_pointer > thread -> tc_stack_end))
;
        LDR     a3,[a1,#&24]                ; Pickup start of stack area
        CMP     sp,a3                       ; Compare with current stack ptr
        BLT     TCT_Stack_Range_Error       ; If less, stack is out of range
        LDR     a2,[a1,#&28]                ; Pickup end of stack area
        CMP     sp,a2                       ; Compare with current stack ptr
        BLE     TCT_Stack_Range_Okay        ; If less, stack range is okay
;
;            /* Stack overflow condition exits.  */
;            ERC_System_Error(NU_STACK_OVERFLOW);
;
TCT_Stack_Range_Error
;
        STR     lr,[sp, #4]!                ; Store lr on the stack
        MOV     a1,#3                       ; Build NU_STACK_OVERFLOW code
        [ THUMB
    	LDR     a4,=ERC_System_Error        ; Call system error handler.  Note:
        BX      a4                          ; control is not returned!
;		    			    ;   Examine stack to find return
;			    		    ;   address of this routine.
        |
        BL      ERC_System_Error             ; Call system error handler.  Note:
;                                            ; control is not returned!  
;                                            ; Examine stack to find return 
;                                            ; address of this routine.
        ]
TCT_Stack_Range_Okay
;
;        /* Calculate the amount of available space on the stack.  */
;        remaining =  (BYTE_PTR) thread -> tc_stack_pointer -
;                          (BYTE_PTR) thread -> tc_stack_start;
;
        SUB     a4,sp,a3                    ; Calculate remaining stack size
;
;        /* Determine if there is enough memory on the stack to save all of the
;           registers.  */
;        if (remaining < 80)
;
        CMP     a4,#80                      ; Is there enough room for an 
                                            ; interrupt frame?
        BCS     TCT_No_Stack_Error          ; If so, no stack overflow yet
;
;            /* Stack overflow condition is about to happen.  */
;            ERC_System_Error(NU_STACK_OVERFLOW);
;
        STR     lr,[sp, #4]!                ; Store lr on the stack
        MOV     a1,#3                       ; Build NU_STACK_OVERFLOW code

        [ THUMB
    	LDR     a4,=ERC_System_Error        ; Call system error handler.  Note:
	    BX      a4                          ;   control is not returned!
;		    			    ;   Examine stack to find return
;			    		    ;   address of this routine.
        |
        BL      ERC_System_Error            ; Call system error handler.  Note:
;                                           ; control is not returned!  
;                                           ; Examine stack to find return 
;                                           ; address of this routine.
        ]

TCT_No_Stack_Error
;
;        /* Determine if this is a new minimum amount of stack space.  */
;        if (remaining < thread -> tc_stack_minimum)
;
        LDR     a3,[a1,#&34]
        CMP     a4,a3
        STRCC   a4,[a1,#&34]
;
;            /* Save the new stack minimum.  */
;            thread -> tc_stack_minimum =  remaining;
;    }