DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400 Tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400 Tapes

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download
Index: ┃ A T

⟦be052f0e2⟧ TextFile

    Length: 46378 (0xb52a)
    Types: TextFile
    Names: »ADAROOT_TSK_LIST«

Derivation

└─⟦afbc8121e⟧ Bits:30000532 8mm tape, Rational 1000, MC68020_OS2000 7_2_2
    └─ ⟦77aa8350c⟧ »DATA« 
        └─⟦f794ecd1d⟧ 
            └─⟦24d1ddd49⟧ 
                └─⟦this⟧ 

TextFile

                                                ;    The use of this system is subject to the software license terms and
                                                ;    conditions agreed upon between Rational and the Customer.
                                                ;
                                                ;                Copyright 1988 by Rational.
                                                ;
                                                ;                          RESTRICTED RIGHTS LEGEND
                                                ;
                                                ;    Use, duplication, or disclosure by the Government is subject to
                                                ;    restrictions as set forth in subdivision (b)(3)(ii) of the Rights in
                                                ;    Technical Data and Computer Software clause at 52.227-7013.
                                                ;
                                                ;
                                                ;                Rational
                                                ;                3320 Scott Boulevard
                                                ;                Santa Clara, California 95054-3197
                                                ;
                                                ;   PROPRIETARY AND CONFIDENTIAL INFORMATION OF RATIONAL;
                                                ;   USE OR COPYING WITHOUT EXPRESS WRITTEN AUTHORIZATION
                                                ;   IS STRICTLY PROHIBITED.  THIS MATERIAL IS PROTECTED AS
                                                ;   AN UNPUBLISHED WORK UNDER THE U.S. COPYRIGHT ACT OF
                                                ;   1976.  CREATED 1988.  ALL RIGHTS RESERVED.
                                                ;
                                                ;
                                                
                                                        .module "ADAROOT_TASKING"
                                                        .include    "^standard_assembler_include_file"
        00000000                                        .push_list
        00000000                                        .pop_list
        00000000                                        .list macro_expansion = none
                                                        .include    "^Common.Runtime_Definitions"
                                                ;
                                                ;   This number is used to check the compatibility
                                                ;   of the program and the loaded shared runtime.
                                                ;   The value must be incremented whenever an execution
                                                ;   incompatible change is made in the runtime.
                                                ;
                                                ;       Version         Incompatible changes in this version
                                                ;       -------         ------------------------------------
                                                ;           0           Initial release of shared runtime
                                                ;
                                                ;           1           Changed Os2000_Process_Defs to use
                                                ;                       special Ada work area rather than
                                                ;                       user accounting area.
                                                ;
                                                ;           2           Added 12 long words of spare storage
                                                ;                       in Runtime_Data; this will permit
                                                ;                       some addition of data in the shared
                                                ;                       runtime to be compatible. 
                                                ;
                                                ;           3           1.) Rev 6 compiler
                                                ;                       2.) Runtime entry point table now 16-bit
                                                ;                           offset from table to entry in words.
                                                ;                       3.) Deleted some unnecessary shared data items.
                                                ;                       4.) General cleanup
                                                        compatibility_version   equ 3
                                                ;
                                                ;   Amount of stack space reserved for the runtime in bytes
                                                ;
                                                        runtime$stack$cushion  equ 1024  
                                                ;
                                                ;   Values for certain runtime error messages and warnings.
                                                ;
                                                        error$code                      equ     16#8000#    
                                                        warning$code                    equ     16#8100#
                                                
                                                        elaboration$ferror              equ     1
                                                        finalization$ferror             equ     2
                                                        unhandled$main$trap$ferror      equ     3
                                                        lib$exception$ferror            equ     5
                                                        main$exception$ferror           equ     6
                                                        init$trap$handler$ferror        equ     37
                                                        insufficient$stack$ferror       equ     44
                                                        no$runtime$ferror               equ     45
                                                        rt$incompatible$ferror          equ     46
                                                
                                                        task$exception$warning          equ     1
                                                        heap$create$warning             equ     2       
                                                        stack$request$warning           equ     4
                                                
                                                ;
                                                ;   Values used in exit system call
                                                ;
                                                
                                                        No$Error                        equ     0
                                                        Some$Error                      equ     1
                                                ;
                                                ;   Comp Unit id for all runtime units except predefined exceptions 
                                                ;
                                                        runtime_compunit                equ     17      
                                                ;
                                                ;   Comp Unit id for predefined exception
                                                ;
                                                        exception_compunit              equ     1
                                                ;
                                                ;   Subprogram kind for runtime suprograms
                                                ;
                                                        sp_rt                           equ     1
                                                ;
                                                ;   Special statement numbers
                                                ;
                                                        stmt.end_prolog                 equ     1
                                                        stmt.begin_epilog               equ     16#7FFF#
                                                ;
                                                ;   Subprogram ids for debug directives within runtime
                                                ;   entry points.
                                                ;
                                                        sp.internal                             equ     16#0_00#
                                                
                                                        sp.enum_image                           equ     16#1_00#
                                                        sp.enum_pos                             equ     16#1_01#
                                                        sp.enum_pred                            equ     16#1_02#
                                                        sp.enum_succ                            equ     16#1_03#
                                                        sp.enum_value                           equ     16#1_04#
                                                        sp.enum_width                           equ     16#1_05#
                                                        sp.int_image                            equ     16#1_06#
                                                        sp.int_value                            equ     16#1_07#
                                                        sp.int_width                            equ     16#1_08#
                                                
                                                        sp.allocate_collection                  equ     16#2_00#
                                                        sp.allocate_fixed_cell                  equ     16#2_01#
                                                        sp.deallocate_collection                equ     16#2_02#
                                                        sp.deallocate_fixed_cell                equ     16#2_03#
                                                        sp.collection_size                      equ     16#2_04#
                                                   
                                                        sp.initialize_master                    equ     16#3_00#
                                                        sp.create_task                          equ     16#3_01#
                                                        sp.activate_offspring                   equ     16#3_02#
                                                        sp.notify_parent                        equ     16#3_03#
                                                        sp.task_end                             equ     16#3_04#
                                                        sp.await_dependents                     equ     16#3_05#
                                                        sp.task_completion                      equ     16#3_06#
                                                        sp.terminate_allocated_offspring        equ     16#3_07#
                                                        sp.terminate_dependent_offspring        equ     16#3_08#
                                                        sp.entry_call                           equ     16#3_09#
                                                        sp.conditional_entry_call               equ     16#3_0A#
                                                        sp.timed_entry_call                     equ     16#3_0B#
                                                        sp.begin_accept                         equ     16#3_0C#
                                                        sp.end_accept                           equ     16#3_0D#
                                                        sp.quick_accept                         equ     16#3_0E#
                                                        sp.close_alternatives                   equ     16#3_0F#
                                                        sp.open_delay                           equ     16#3_10#
                                                        sp.open_entry                           equ     16#3_11#
                                                        sp.open_terminate                       equ     16#3_12#
                                                        sp.select_rendezvous                    equ     16#3_13#
                                                        sp.abort_multiple_tasks                 equ     16#3_14#
                                                        sp.check_return_task                    equ     16#3_15#
                                                        sp.delay_statement                      equ     16#3_16#
                                                        sp.entry_count                          equ     16#3_17#
                                                        sp.task_callable                        equ     16#3_18#
                                                        sp.task_stack_size                      equ     16#3_19#
                                                        sp.task_terminated                      equ     16#3_1A#
                                                
                                                        sp.raise_exception                      equ     16#4_00#
                                                        sp.raise_constraint_error               equ     16#4_01#
                                                        sp.propagate_exception                  equ     16#4_02#
                                                        sp.stack_check                          equ     16#4_03#
                                                
                                                        sp.mantissa                             equ     16#5_00#
                                                        sp.large                                equ     16#5_01#
                                                        sp.fixed_multiply                       equ     16#5_02#
                                                        sp.compare_8_bit_unsigned               equ     16#5_03#
                                                        sp.compare_8_bit_signed                 equ     16#5_04#
                                                        sp.compare_16_bit_unsigned              equ     16#5_05#
                                                        sp.compare_16_bit_signed                equ     16#5_06#
                                                        sp.compare_32_bit_unsigned              equ     16#5_07#
                                                        sp.compare_32_bit_signed                equ     16#5_08#
                                                ;
                                                ;   Linkage mechanisms used in assembly routines.
                                                ;
                                                ;       Identification of the mechanism in a .subprogram directive
                                                ;       and information provided in .statement directives enable
                                                ;       the debugger to find the return pc.
                                                ;
                                                        linkage.frame   equ 16#00_00_00_00#     ; return pc may be found at
                                                                                                ; offset from frame pointer
                                                
                                                        linkage.simple  equ 16#10_00_00_00#     ; return pc may be found at
                                                                                                ; offset from stack pointer
                                                
                                                        linkage.none    equ 16#50_00_00_00#     ; no return pc exists,
                                                                                                ; in bottom routine
                                                
                                                        linkage.trap    equ 16#60_00_00_00#     ; in trap handling code
                                                ;
                                                ;       Definitions for locking primitives
                                                ;
                                                
                                                                .offset 0       ;  type Q_Element is
                                                                                ;      record
        00000008                                element'size:                   ;      end record;
                                                ;
                                                ;       Ada task control block (TCB) definitions
                                                ;
                                                                                .offset 0
                                                
                                                                                
                                                
        00000050                                tcb'size:
                                                
                                                b.action_state.exception_pending        equ     3
                                                
                                                        .include    "^Common.Os2000_Definitions"    
                                                ;
                                                ;       Definitions for CCT (Communication Control Table)
                                                ;
                                                
                                                cct_start       equ     1024     ; CCT offset from window start
                                                pi_cpt          equ     88       ; Offset for pointer to CPT
                                                ;
                                                ;       HSI addressing conventions
                                                ;
                                                a32_size        equ     16#02000000#;
                                                ;
                                                ;       Offsets in the Configuration Parameter Table.
                                                ;
                                                CPT_System_Time         equ     0       ; Offset to system time HW pointer
                                                
                                                CPT_Political_Time      equ     4       ; Offset to political time offset
                                                
                                                CPT_Current_Proc        equ     64      ; Offset to Os9 current process pointer 
                                                 
                                                
                                                CPT_MsgQ_Pointer        equ     144     ; Offset to Message_Queues pointer
                                                                                        ; points to MqGlobals control block
                                                
                                                CPT_Ada_Runtime_Ptr     equ     152     ; Offset in CPT to Ada Runtime pointer
                                                                                        ; points to beginning of table of
                                                                                        ; runtime entry points
                                                ;
                                                ;       OS9 system call definitions
                                                ;
                                                        os9_call        equ     0
                                                ;
                                                ;       An OS9 system call is perform with the following sequence:
                                                ;               trap    #OS9_Call
                                                ;               .dc.w   call_code
                                                ;
                                                ;       where call code is one of the following user mode calls
                                                ;       or I/O calls
                                                ;    
                                                ;       User mode system call definitions
                                                ;
                                                        F$Exit          equ     16#006#
                                                        F$Fork          equ     16#003#
                                                        F$Icpt          equ     16#009#
                                                        F$Julian        equ     16#020#
                                                        F$Link          equ     16#000#
                                                        F$PEAB          equ     16#0FA#
                                                        F$PErr          equ     16#00F#
                                                        F$RTE           equ     16#01E#
                                                        F$SPrior        equ     16#00D#
                                                        F$SRqMem        equ     16#028#
                                                        F$STime         equ     16#016#
                                                        F$STrap         equ     16#00E#
                                                        F$Send          equ     16#008#
                                                        F$Sleep         equ     16#00A#
                                                        F$Time          equ     16#015#
                                                ;
                                                ;       OS9 I/O system call definitions
                                                ;
                                                        I$Close         equ     16#08F#
                                                        I$Create        equ     16#083#
                                                        I$Delete        equ     16#087#
                                                        I$GetStt        equ     16#08D#
                                                        I$Last          equ     16#093#
                                                        I$Open          equ     16#084#
                                                        I$Read          equ     16#089#
                                                        I$ReadLn        equ     16#08B#
                                                        I$SGetSt        equ     16#092#
                                                        I$Seek          equ     16#088#
                                                        I$SetStt        equ     16#08E#
                                                        I$WritLn        equ     16#08C#
                                                        I$Write         equ     16#08A#;
                                                ;
                                                ;       Access mode for Open
                                                ;
                                                        Read_Mode       equ     1
                                                        Write_Mode      equ     2
                                                        Execute         equ     4
                                                ;
                                                ;       Function codes for the I$GetStt call
                                                ;
                                                        SS_Opt          equ     16#0000#
                                                        SS_Size         equ     16#0002#
                                                        SS_Pos          equ     16#0005#
                                                        SS_EOF          equ     16#0006#
                                                        SS_DevNm        equ     16#000E#
                                                ;
                                                ;       Standard paths
                                                ;
                                                        Standard_Input  equ     0
                                                        Standard_Output equ     1
                                                        Standard_Error  equ     2
                                                ;
                                                ;       I/O Error Codes
                                                ;
                                                        E$BPNum         equ     16#00C9#        ; bad path number
                                                ;
                                                ;       OS9 trap definitions
                                                ;
                                                        T_AddErr        equ     16#000C#
                                                        T_BusErr        equ     16#0008#
                                                        T_IllIns        equ     16#0010#
                                                        T_CHK           equ     16#0018#
                                                        T_TRAPV         equ     16#001C#
                                                        T_FPDivZer      equ     16#00C8#
                                                        T_FPInxact      equ     16#00C4#
                                                        T_FPNotNum      equ     16#00D8#
                                                        T_FPOprErr      equ     16#00D0#
                                                        T_FPOverFl      equ     16#00D4#
                                                        T_FPUndrFl      equ     16#00CC#
                                                        T_FPUnordC      equ     16#00C0#
                                                        T_ZerDiv        equ     16#0014#
                                                ;
                                                ;       OS2000 process descriptor definitions
                                                ;
                                                P$DefIOSiz      equ 32          ; Default I/O data area size
                                                P$NumPaths      equ 32          ; Number of local paths            
                                                P$MemBlks       equ 32          ; Number of separate memory blocks per process
                                                
                                                                .offset 0       ; Process descriptor
        00000398                                p$JobCon:
        000003A8                                P$AdaWrk:
        000003E8                                P$Last:                         ; Size of a process header
        00000800                                P$Stack:                        ; Top of system stack for process
        00000800                                P$Size:                         ; Size of process descriptor
                                                ;
                                                ;       Values for process state (P$STATE)
                                                ;
                                                P$SysState      equ     16#80#  ; Executing system state routine
                                                P$TimSleep      equ     16#40#  ; Timed sleep
                                                P$TimOut        equ     16#20#  ; time slice has expired
                                                P$ImgChg        equ     16#10#  ; SPU/MMU protection map has changed
                                                P$Condemn       equ     16#02#  ; process is condemned
                                                P$Dead          equ     16#01#  ; Process has terminated
                                                ;
                                                ;       Values for process queue id (P$QUEUID
                                                ;
                                                P$QActive       equ     'a'     ; active process queue
                                                P$QSleep        equ     's'     ; sleep queue
                                                P$QWait         equ     'w'     ; Waiting queue
                                                P$QEvent        equ     'e'     ; Event queue
                                                P$QCurrnt       equ     '*'     ; No queue, currently running
                                                P$QDebug        equ     'd'     ; No queue, inactively debugging
                                                P$QDead         equ     '-'     ; No queue, dead process
                                                ;
                                                ; User register stack image
                                                ;
                                                                .offset 0
        00000048                                R$Size:                         ; Size of register package
                                                
                                                ;
                                                ; Status register equates
                                                ;
                                                R$TraceBit      equ     16#8000#    ; Trace bit in SR word
                                                R$SupvrBit      equ     16#2000#    ; Supervisor bit in SR word
                                                R$IntMask       equ     16#0700#    ; Interrupt mask in SR word
                                                R$Extend        equ     16#0010#    ; Extend bit
                                                R$Negative      equ     16#0008#    ; Negative bit
                                                R$Zero          equ     16#0004#    ; Zero bit
                                                R$Ov            equ     16#0002#    ; Overflow
                                                R$Carry         equ     16#0001#    ; Carry 
                                                
                                                ; 68881 FPU context save area
                                                                .offset 0
                                                        comp_unit  Runtime_Compunit
                                                 
                                                
                                                        .sect   ada_runtime_code,code,relocatable,alignment:=2
                                                
                                                ;
                                                ;   Defines the runtime entry points for Start, Middle, and Finish
                                                ;   of tasking programs.
                                                ;
                                                
                                                        .gbl.l  __Start_Tasking     
                                                        .ext.l  _.Start_Tasking     
                                                        .gbl.l  __Finish_Tasking    
                                                        .ext.l  _.Finish_Tasking    
                                                
                                                        .gbl.l  __debug.tsk_root_creation
                                                        .gbl.l  __debug.tsk_root_termination
                                                
                                                        .gbl.l  __debug.task_creation
                                                        .gbl.l  __debug.task_termination
                                                        .gbl.l  __Process_Exit
                                                        .ext.l  __task_end
                                                
                                                        .ext.l  __debug.raise
                                                        .ext.l  __defined_heap_size
                                                        .ext.l  __Main_Priority
                                                        .ext.l  __Data_Area_Size
                                                
                                                        .ext.l  __Main_Code_Start_Var
                                                        .ext.l  __Main_Code_Start_Copy
                                                        .ext.l  __Heap_Size_Var
                                                        .ext.l  __Main_Priority_Var
                                                        .ext.l  __Data_Size_Var
                                                
                                                        .ext.l  __Root_Create_Return
                                                        .ext.l  __Task_Create_Return
                                                        .ext.l  __Root_Finish_Return
                                                        .ext.l  __Task_Finish_Return
                                                        .ext.w  __Finish_Entry_Offset
                                                        .ext.l  __Propagate_Exception_Branch
                                                        .ext.l  __TDlyStm_Indirect
                                                        .ext.l  __Runtime_Entry_Pointer
                                                        .ext.l  __Put_Error_Msg_And_Exit
                                                        .ext.l  __Runtime_Compatibility_Value
                                                
                                                        .ext.l  __Ada_Init_Values_Begin
                                                        .ext.l  __Ada_Init_Values_End
                                                        .ext.l  __Ada_Init_Data_Begin
                                                
                                                ;
                                                ;  Initial entry point from the program after fork; the
                                                ;  return address to the program is passed in A0.  All other
                                                ;  registers except D4, D7, A2, and A4 contain information
                                                ;  about the fork which is used in subsequent code.
                                                ;
                                                
                                                        subprogram  sp_rt,sp.internal,linkage.none
                                                 
        00000000                                __Start_Tasking:     
        00000000   2800                                 move.l  d0,d4                           ; save process id in d4
                                                ;
                                                ;   Setup global data pointer
                                                ;
        00000002   244D                                 movea.l a5,a2                           ; save parameter pointer in temp
                                                
        00000004   93C6                                 suba.l  d6,a1                           ; get base address for globals
        00000006   2A49                                 movea.l a1,a5                           ; setup global base register
                                                ;
                                                ;   Move data from ADA_INIT_VALUES section to ADA_INIT_DATA section.
                                                ;
        00000008   48E70128                             movem.l d7/a2/a4,-(a7)                  ; Save working regs
        0000000C   45FB017000000000                     lea.l   (__Ada_Init_Values_Begin,pc),a2 ; Get source of move
        00000014   49FB017000000000                     lea.l   (__Ada_Init_Values_End,pc),a4   ; Compute length of move
        0000001C   2E0C                                 move.l  a4,d7
        0000001E   9E8A                                 sub.l   a2,d7
        00000020   6700                                 beq.s   $no_copy                        ; -> Nothing to move
                                                        
        00000022   49F5017000000000                     lea.l   (__Ada_Init_Data_Begin,a5),a4   ; Get destination of move
        0000002A   5687                                 addq.l  #3,d7                           ; Round up to 4 byte multiple
        0000002C   E48F                                 lsr.l   #2,d7                           ; Convert to count of 4 byte obj
                                                ects
        0000002E   2807                                 move.l  d7,d4                           ; Make copy of count
        00000030   4844                                 swap    d4                              ; LSW of d4 is MSW of d7
        00000032   6000                                 bra.s   $enter_loop                     ; -> Begin loop
                                                              
                                                ; Assertion: source and dest sections were 32 bit aligned, so a
                                                ; 32-bit-at-a-time copy is correct.
        00000034   28DA                         $copy:  move.l  (a2)+,(a4)+                     ; Move a byte
        00000036                                $enter_loop:
        00000036   51CFFFFC                             dbra    d7,$copy                        ; -> Loop on copy
        0000003A   51CCFFF8                             dbra    d4,$copy                        ; -> Loop on large copy
                                                
        0000003E                                $no_copy:
        0000003E   4CDF1480                             movem.l (a7)+,d7/a2/a4                  ; Restore working regs
                                                
                                                ;
                                                ;   Store address for return to user code and
                                                ;   shared runtime offset for Finish 
                                                ;
        00000042   2B88017000000000                     move.l  a0,(__main_code_start_var,a5)   ; save code start
        0000004A   2B88017000000000                     move.l  a0,(__main_code_start_copy,a5)  ; save code start for debugger
                                                ;
                                                ;   Store values associated with current code segment
                                                ;
        00000052   41FB017000000000                     lea     (__debug.raise,PC),a0           ; compute address for raise brk
        0000005A   2B88017000000000                     move.l  a0,(__Propagate_Exception_Branch,a5) ; store for branch from rt
        00000062   41FB017000000000                     lea     ($root_create_return,pc),a0     ; compute address for create
        0000006A   2B88017000000000                     move.l  a0,(__Root_Create_Return,a5)    ; store for branch from rt
        00000072   41FB017000000000                     lea     (__debug.task_creation,pc),a0   ; compute address for create
        0000007A   2B88017000000000                     move.l  a0,(__Task_Create_Return,a5)    ; store for branch from rt
        00000082   41FB017000000000                     lea     (__debug.task_termination,PC),a0; compute address for term 
        0000008A   2B88017000000000                     move.l  a0,(__Task_Finish_Return,a5)    ; store for branch from rt
                                                
        00000092   2BBC00000000017000000000             move.l  #__main_priority,(__main_priority_var,a5)
        0000009E   2BBB017000000000017000000000         move.l  (__defined_heap_size,pc),(__heap_size_var,a5)
        000000AC   2BBC00000000017000000000             move.l  #__data_area_size,(__data_size_var,a5)
        000000B8   1BBC0003017000000000                 move.b  #compatibility_version,(__runtime_compatibility_value,a5)
                                                ;
                                                ;   setup pointer to runtime entry point table
                                                ;
        000000C2   2E0F                                 move.l  sp,d7                           ; get current stack pointer
        000000C4   0287FE000000                         andi.l  #(-a32_size),d7                 ; mask for high order bits
        000000CA   207079A00458                         movea.l ((cct_start + pi_cpt),d7),a0    ; get CPT address
                                                
        000000D0   2E280098                             move.l  (cpt_ada_runtime_ptr,a0),d7     ; get runtime table pointer
        000000D4   6700                                 beq.b   $no_runtimes                    ; if Z, then no runtime
        000000D6   2B87017000000000                     move.l  d7,(__runtime_entry_pointer,a5) ; store table pointer
                                                
        000000DE   61FF00000000                         bsr.l   _.start_tasking
        000000E4                                __debug.tsk_root_creation:
        000000E4                                $root_create_return:
        000000E4   4EF5017100000000                     jmp     ([__main_code_start_var,a5])    ; jump to program start
                                                ;
                                                ;   Runtime table pointer was zero
                                                ;
        000000EC                                $no_runtimes:
        000000EC   323C002D                             move.w  #no$runtime$ferror,d1           ; load error code
        000000F0   60000000                             bra.w   __put_error_msg_and_exit        ; give message and die
                                                ;
                                                ;   Finish calls from user program
                                                ;
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        000000F4                                __Finish_Tasking:
        000000F4   61FF00000000                         bsr.l   _.finish_tasking
                                                
        000000FA                                __debug.tsk_root_termination:
        000000FA   7200                                 moveq   #No$Error,d1
        000000FC   4E40                                 trap     #OS9_Call
        000000FE   0006                                 .dc.w    F$Exit
                                                ;
                                                ;   Branch from shared runtime after initialization of task.
                                                ;   Pointer to current TCB is in A4.
                                                ;
        00000100                                __debug.task_creation:
        00000100   41F401610010                         lea     ([tcb.code_start,a4]),a0        ; get address of elab object  
        00000106   4EB00151                             jsr     ([a0])                          ; execute user code 
        0000010A   61FF00000000                         bsr.l   __task_end
                                                
        00000110                                __process_exit:
        00000110                                __debug.task_termination:
        00000110   7200                                 moveq.l #no$error,d1
        00000112   4E40                                 trap    #os9_call
        00000114   0006                                 .dc.w   f$exit
                                                
                                                        end_subprograms
                                                 
                                                
                                                        .end


      Program Section Name       Kind   Length   Patches Fixups
-------------------------------- ---- ---------- ------- -------
ADA_RUNTIME_CODE                  Rel        278       4      27
DEBUG_BODY                        Rel         34       4       2
DEBUG_HDR_CU                      Rel         19       2       0


Standard include file: <none>
Object module version: 11

        Assembled 1530 lines in 15.309 elapsed, 12.365 CPU.
         5996 lines per elapsed minute.
         7424 lines per CPU minute.
         39 disk waits for this job.
         654367 bytes of heap used by this job.