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: ┃ F T

⟦3e4bc15c6⟧ TextFile

    Length: 41080 (0xa078)
    Types: TextFile
    Names: »FLOAT_OPS_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 1987, 1988, 1989 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
                                                ;
                                                ;   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 1987, 1988, 1989.  ALL RIGHTS RESERVED.
                                                ;
                                                ;
                                                
                                                        .module "FLOAT_OPERATIONS"
                                                
                                                        .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
                                                
                                                        
                                                        comp_unit runtime_compunit
                                                 
                                                
                                                        .sect   ada_runtime_code,code,readonly,relocatable,alignment:=2
                                                
                                                        .gbl.l  __single_to_extended
                                                        .gbl.l  __double_to_extended
                                                        .gbl.l  __extended_to_single
                                                        .gbl.l  __extended_to_double
                                                
                                                        .gbl.l  __single_to_packed
                                                        .gbl.l  __double_to_packed
                                                        .gbl.l  __integer_to_packed  
                                                        .gbl.l  __packed_to_single
                                                        .gbl.l  __packed_to_double
                                                
                                                        .gbl.l  __extended_to_packed
                                                        .gbl.l  __packed_to_extended
                                                        .gbl.l  __integer_to_extended
                                                    
                                                        .gbl.l  __accumulate_digit
                                                        .gbl.l  __binary_exponentiate
                                                        .gbl.l  __based_exponentiate
                                                        .gbl.l  __packed_exponentiate
                                                
                                                ;
                                                ;    procedure Single_To_Extended (Source :     Single_Float;
                                                ;                                  Target : out Extended_Float);
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        00000000                                __single_to_extended:
                                                        .local
                                                        
                                                        $source'offset  equ 4
                                                        $target'offset  equ 8
                                                
        00000000   F22F44000004                         fmove.s ($source'offset,sp),fp0
        00000006   F237680001610008                     fmove.x fp0,([$target'offset,sp])
        0000000E   4E740008                             rtd     #8
                                                ;
                                                ;    function Extended_To_Single (F : Extended_Float) return Single_Float;
                                                ;
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        00000012                                __extended_to_single:
                                                        .local
                                                        
                                                        $f'offset       equ 4
                                                
        00000012   F237480001610004                     fmove.x ([$f'offset,sp]),fp0
        0000001A   4E740004                             rtd     #4
                                                ;
                                                ;    procedure Double_To_Extended (Source :     Double_Float;
                                                ;                                  Target : out Extended_Float);
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        0000001E                                __double_to_extended:
                                                        .local
                                                        
                                                        $source'offset  equ 4
                                                        $target'offset  equ 12
                                                
        0000001E   F22F54000004                         fmove.d ($source'offset,sp),fp0  
        00000024   F23768000161000C                     fmove.x fp0,([$target'offset,sp])
        0000002C   4E74000C                             rtd     #12
                                                ;
                                                ;    function Extended_To_Double (F : Extended_Float) return Double_Float;
                                                ;
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        00000030                                __extended_to_double:
                                                        .local
                                                        
                                                        $f'offset       equ 4
                                                
        00000030   F237480001610004                     fmove.x ([$f'offset,sp]),fp0
        00000038   4E740004                             rtd     #4
                                                ;
                                                ;    procedure Single_To_Packed (Source :     Single_Float;
                                                ;                                Target : out Packed_Float;
                                                ;                                K      :     K_Factor);
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        0000003C                                __single_to_packed:
                                                        .local
                                                        
                                                        $source'offset          equ 4
                                                        $target'offset          equ 8
                                                        $k_factor'offset        equ 12
                                                
        0000003C   F22F44000004                         fmove.s ($source'offset,sp),fp0        ; load single precision value 
        00000042   202F000C                             move.l  ($k_factor'offset,sp),d0       ; get k-factor
        00000046   F2377C0001610008                     fmove.p fp0,([$target'offset,sp]){d0}  ; store to out parameter
        0000004E   4E74000C                             rtd     #12
                                                ;
                                                ;    function Packed_To_Single (F : Packed_Float) return Single_Float;
                                                ;
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        00000052                                __packed_to_single:
                                                        .local
                                                        
                                                        $f'offset       equ 4
                                                
        00000052   F2374C0001610004                     fmove.p ([$f'offset,sp]),fp0
        0000005A   4E740004                             rtd     #4
                                                ;
                                                ;    procedure Integer_To_Packed (Source :     Integer;
                                                ;                                 Target : out Packed_Float;
                                                ;                                 K      :     K_Factor);
                                                ;
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        0000005E                                __integer_to_packed:
                                                        .local
                                                        
                                                        $source'offset          equ 4
                                                        $target'offset          equ 8
                                                        $k_factor'offset        equ 12
                                                
        0000005E   F22F40000004                         fmove.l ($source'offset,sp),fp0
        00000064   202F000C                             move.l  ($k_factor'offset,sp),d0
        00000068   F2377C0001610008                     fmove.p fp0,([$target'offset,sp]){d0}
        00000070   4E74000C                             rtd     #12
                                                ;
                                                ;    procedure Double_To_Packed (Source :     Double_Float;
                                                ;                                Target : out Packed_Float;
                                                ;                                K      :     K_Factor);
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        00000074                                __double_to_packed:
                                                        .local
                                                        
                                                        $source'offset          equ 4
                                                        $target'offset          equ 12
                                                        $k_factor'offset        equ 16
                                                
        00000074   F22F54000004                         fmove.d ($source'offset,sp),fp0
        0000007A   202F0010                             move.l  ($k_factor'offset,sp),d0 
        0000007E   F2377C000161000C                     fmove.p fp0,([$target'offset,sp]){d0}
        00000086   4E740010                             rtd     #16
                                                ;
                                                ;    function Packed_To_Double (F : Packed_Float) return Double_Float;
                                                ;
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        0000008A                                __packed_to_double:
                                                        .local
                                                        
                                                        $f'offset       equ 4
                                                
        0000008A   F2374C0001610004                     fmove.p ([$f'offset,sp]),fp0
        00000092   4E740004                             rtd     #4
                                                ;
                                                ;    procedure Extended_To_Packed (Source :     Extended_Float;
                                                ;                                  Target : out Packed_Float;
                                                ;                                  K      :     K_Factor := K_Factor'Last);
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        00000096                                __extended_to_packed:
                                                        .local
                                                        
                                                        $source'offset          equ 4
                                                        $target'offset          equ 8
                                                        $k_factor'offset        equ 12
                                                
        00000096   F237480001610004                     fmove.x ([$source'offset,sp]),fp0
        0000009E   202F000C                             move.l  ($k_factor'offset,sp),d0
        000000A2   F2377C0001610008                     fmove.p fp0,([$target'offset,sp]){d0}
        000000AA   4E74000C                             rtd     #12
                                                ;
                                                ;    procedure Packed_To_Extended (Source :     Packed_Float;
                                                ;                                  Target : out Extended_Float);
                                                ;
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        000000AE                                __Packed_To_Extended:
                                                        .local
                                                        
                                                        $source'offset  equ 4
                                                        $target'offset  equ 8
                                                
        000000AE   F2374C0001610004                     fmove.p ([$source'offset,sp]),fp0
        000000B6   F237680001610008                     fmove.x fp0,([$target'offset,sp])
        000000BE   4E740008                             rtd     #8
                                                ;
                                                ;
                                                ;    procedure Integer_To_Extended (Value  :     Integer;
                                                ;                                   Result : out Extended_Float;
                                                ;
                                                ;
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        000000C2                                __integer_to_extended:
                                                        .local
                                                        
                                                        $value'offset   equ 4
                                                        $result'offset  equ 8
                                                
        000000C2   F22F40010004                         fint.l  ($value'offset,sp),fp0  
        000000C8   F237680001610008                     fmove.x fp0,([$result'offset,sp])
        000000D0   4E740008                             rtd     #8
                                                ;
                                                ;    procedure Accumulate_Digit (Digit :        Natural;
                                                ;                                Fbase :        Extended_Float;
                                                ;                                Value : in out Extended_Float);
                                                ;
                                                ;       Value := (Value * Fbase) + Float (Digit)
                                                ;
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        000000D4                                __Accumulate_Digit:
                                                        .local
                                                        
                                                        $digit'offset   equ 4
                                                        $fbase'offset   equ 8
                                                        $value'offset   equ 12
                                                
        000000D4   F237480001610008                     fmove.x ([$fbase'offset,sp]),fp0   
        000000DC   F23748230161000C                     fmul.x  ([$value'offset,sp]),fp0  
        000000E4   F22F40220004                         fadd.l  ($digit'offset,sp),fp0    
        000000EA   F23768000161000C                     fmove.x fp0,([$value'offset,sp])  
        000000F2   4E74000C                             rtd     #12
                                                ;
                                                ;    procedure Binary_Exponentiate (Exponent :        Integer;
                                                ;                                   Value    : in out Extended_Float);
                                                ;
                                                ;       Value := Value * (2 ** Exponent)
                                                ;
                                                ;
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        000000F6                                __binary_exponentiate:
                                                        .local
                                                        
                                                        $exponent'offset        equ 4
                                                        $value'offset           equ 8
                                                
        000000F6   F237480001610008                     fmove.x ([$value'offset,sp]),fp0
        000000FE   F22F40260004                         fscale.l ($exponent'offset,sp),fp0 
        00000104   F237680001610008                     fmove.x fp0, ([$value'offset,sp])
        0000010C   4E740008                             rtd     #8
                                                ;
                                                ;    procedure Based_Exponentiate (Exponent :        Integer;
                                                ;                                  Ebase    :        Extended_Float;
                                                ;                                  Value    : in out Extended_Float);
                                                ;
                                                ;       Value := Value * (Ebase ** Exponent)
                                                ;    
                                                ;
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        00000110                                __based_exponentiate:
                                                        .local
                                                        
                                                        $exponent'offset        equ 4
                                                        $ebase'offset           equ 8
                                                        $value'offset           equ 12
                                                                                   
        00000110   F237481401610008                     flogn.x ([$ebase'offset,sp]),fp0
        00000118   F22F40230004                         fmul.l  ($exponent'offset,sp),fp0
        0000011E   F2000010                             fetox.x fp0,fp0                  
                                                                                          
        00000122   F23748230161000C                     fmul.x  ([$value'offset,sp]),fp0 
        0000012A   F23768000161000C                     fmove.x fp0,([$value'offset,sp]) 
        00000132   4E74000C                             rtd     #12
                                                ;
                                                ;    procedure Packed_Exponentiate (Exponent :     Integer;
                                                ;                                   Value    :     Packed_Float;
                                                ;                                   Result   : out Extended_Float);
                                                ;
                                                ;       Result := Value * (10 ** Exponent)
                                                ;    
                                                ;
                                                        subprogram sp_rt,sp.internal,linkage.simple
                                                 
        00000136                                __packed_exponentiate:
                                                        .local
                                                        
                                                        $exponent'offset        equ 4
                                                        $value'offset           equ 8
                                                        $result'offset          equ 12
                                                
        00000136   F22F40120004                         ftentox.l ($exponent'offset,sp),fp0
        0000013C   F2374C2301610008                     fmul.p    ([$value'offset,sp]),fp0
        00000144   F23768000161000C                     fmove.x   fp0,([$result'offset,sp]) 
        0000014C   4E74000C                             rtd     #12
                                                
                                                        end_subprograms
                                                 
                                                
                                                        .end


      Program Section Name       Kind   Length   Patches Fixups
-------------------------------- ---- ---------- ------- -------
ADA_RUNTIME_CODE                  Rel        336       0      16
DEBUG_BODY                        Rel        272      32      16
DEBUG_HDR_CU                      Rel         61       2       0


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

        Assembled 4736 lines in 35.907 elapsed, 25.803 CPU.
         7914 lines per elapsed minute.
         11013 lines per CPU minute.
         85 disk waits for this job.
         898400 bytes of heap used by this job.