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

⟦c1d79faf0⟧ TextFile

    Length: 26575 (0x67cf)
    Types: TextFile
    Names: »V«

Derivation

└─⟦516dceb10⟧ Bits:30000751 8mm tape, Rational 1000, RCI_VADS
    └─ ⟦9a14c9417⟧ »DATA« 
        └─⟦this⟧ 

TextFile

package Machine_Code is

    -- Description for the MC68000, MC68010, CPU32, MC68020, MC68030, MC68040,
    -- MC68851, and MC68881/MC68882.

    pragma Suppress (All_Checks);
    pragma Suppress (Exception_Tables);
    pragma Not_Elaborated;

    type Opcode is (Abcd, Abcd_B, Add_B, Add_W, Add_L, Adda_W, Adda_L, Addi_B,
                    Addi_W, Addi_L, Addq_B, Addq_W, Addq_L, Addx_B, Addx_W,
                    Addx_L, And_B, And_W, And_L, Andi_B, Andi_W, Andi_L, Asl_B,
                    Asl_W, Asl_L, Asr_B, Asr_W, Asr_L, Bcc, Bcs, Beq, Bge,
                    Bgt, Bhi, Ble, Bls, Blt, Bmi, Bne, Bpl, Bvc, Bvs, Bchg_B,
                    Bchg_L, Bclr_B, Bclr_L, Bfchg, Bfclr, Bfexts, Bfextu, Bfffo,
                    Bfins, Bfset, Bftst, Bgnd, Bkpt, Bra, Bset_B, Bset_L, Bsr,
                    Btst_B, Btst_L, Callm, Cas_B, Cas_W, Cas_L, Cas2_W, Cas2_L,
                    Chk_W, Chk_L, Chk2_B, Chk2_W, Chk2_L, Cinvl, Cinvp, Cinva,
                    Cpushl, Cpushp, Cpusha, Clr_B, Clr_W, Clr_L, Cmp_B, Cmp_W,
                    Cmp_L, Cmpa_W, Cmpa_L, Cmpi_B, Cmpi_W, Cmpi_L, Cmpm_B,
                    Cmpm_W, Cmpm_L, Cmp2_B, Cmp2_W, Cmp2_L, Dbcc, Dbcs, Dbeq,
                    Dbf, Dbge, Dbgt, Dbhi, Dble, Dbls, Dblt, Dbmi, Dbne, Dbpl,
                    Dbt, Dbvc, Dbvs, Divs_W, Divs_L, Divsl_L, Divu_W, Divu_L,
                    Divul_L, Eor_B, Eor_W, Eor_L, Eori_B, Eori_W, Eori_L,
                    Exg, Exg_L, Ext_W, Ext_L, Extb_L, Illegal, Jmp, Jsr, Lea,
                    Lea_L, Link_W, Link_L, Lpstop, Lsl_B, Lsl_W, Lsl_L, Lsr_B,
                    Lsr_W, Lsr_L, Move16, Move_B, Move_W, Move_L, Movea_W,
                    Movea_L, Movec, Movec_L, Movem_W, Movem_L, Movep_W, Movep_L,
                    Moveq, Moveq_L, Moves_B, Moves_W, Moves_L, Muls_W, Muls_L,
                    Mulu_W, Mulu_L, Nbcd, Nbcd_B, Neg_B, Neg_W, Neg_L, Negx_B,
                    Negx_W, Negx_L, Nop, Not_B, Not_W, Not_L, Or_B, Or_W, Or_L,
                    Ori_B, Ori_W, Ori_L, Pack, Pea, Pea_L, Reset, Rol_B, Rol_W,
                    Rol_L, Ror_B, Ror_W, Ror_L, Roxl_B, Roxl_W, Roxl_L, Roxr_B,
                    Roxr_W, Roxr_L, Rtd, Rte, Rtm, Rtr, Rts, Sbcd, Sbcd_B,
                    Scc, Scs, Seq, Sf, Sge, Sgt, Shi, Sle, Sls, Slt, Smi,
                    Sne, Spl, St, Svc, Svs, Scc_B, Scs_B, Seq_B, Sf_B, Sge_B,
                    Sgt_B, Shi_B, Sle_B, Sls_B, Slt_B, Smi_B, Sne_B, Spl_B,
                    St_B, Svc_B, Svs_B, Stop, Sub_B, Sub_W, Sub_L, Suba_W,
                    Suba_L, Subi_B, Subi_W, Subi_L, Subq_B, Subq_W, Subq_L,
                    Subx_B, Subx_W, Subx_L, Swap, Swap_W, Tas, Tas_B, Tbls_B,
                    Tbls_W, Tbls_L, Tblsn_B, Tblsn_W, Tblsn_L, Tblu_B, Tblu_W,
                    Tblu_L, Tblun_B, Tblun_W, Tblun_L, Trap, Trapcc, Trapcs,
                    Trapeq, Trapf, Trapge, Trapgt, Traphi, Traple, Trapls,
                    Traplt, Trapmi, Trapne, Trappl, Trapt, Trapvc, Trapvs,
                    Trapcc_W, Trapcs_W, Trapeq_W, Trapf_W, Trapge_W, Trapgt_W,
                    Traphi_W, Traple_W, Trapls_W, Traplt_W, Trapmi_W, Trapne_W,
                    Trappl_W, Trapt_W, Trapvc_W, Trapvs_W, Trapcc_L, Trapcs_L,
                    Trapeq_L, Trapf_L, Trapge_L, Trapgt_L, Traphi_L, Traple_L,
                    Trapls_L, Traplt_L, Trapmi_L, Trapne_L, Trappl_L, Trapt_L,
                    Trapvc_L, Trapvs_L, Trapv, Tst_B, Tst_W, Tst_L, Unlk,
                    Unpk, Pbbs, Pbbc, Pbls, Pblc, Pbss, Pbsc, Pbas, Pbac,
                    Pbws, Pbwc, Pbis, Pbic, Pbgs, Pbgc, Pbcs, Pbcc, Pdbbs,
                    Pdbbc, Pdbls, Pdblc, Pdbss, Pdbsc, Pdbas, Pdbac, Pdbws,
                    Pdbwc, Pdbis, Pdbic, Pdbgs, Pdbgc, Pdbcs, Pdbcc, Pflusha,
                    Pflush, Pflushan, Pflushn, Pflushs, Pflushr, Ploadr,
                    Ploadw, Pmove_B, Pmove_W, Pmove_L, Pmove_Q, Pmovefd_W,
                    Pmovefd_L, Pmovefd_Q, Prestore, Psave, Psbs, Psbc, Psls,
                    Pslc, Psss, Pssc, Psas, Psac, Psws, Pswc, Psis, Psic,
                    Psgs, Psgc, Pscs, Pscc, Psbs_B, Psbc_B, Psls_B, Pslc_B,
                    Psss_B, Pssc_B, Psas_B, Psac_B, Psws_B, Pswc_B, Psis_B,
                    Psic_B, Psgs_B, Psgc_B, Pscs_B, Pscc_B, Ptestr, Ptestw,
                    Ptrapbs, Ptrapbc, Ptrapls, Ptraplc, Ptrapss, Ptrapsc,
                    Ptrapas, Ptrapac, Ptrapws, Ptrapwc, Ptrapis, Ptrapic,
                    Ptrapgs, Ptrapgc, Ptrapcs, Ptrapcc, Ptrapbs_W, Ptrapbc_W,
                    Ptrapls_W, Ptraplc_W, Ptrapss_W, Ptrapsc_W, Ptrapas_W,
                    Ptrapac_W, Ptrapws_W, Ptrapwc_W, Ptrapis_W, Ptrapic_W,
                    Ptrapgs_W, Ptrapgc_W, Ptrapcs_W, Ptrapcc_W, Ptrapbs_L,
                    Ptrapbc_L, Ptrapls_L, Ptraplc_L, Ptrapss_L, Ptrapsc_L,
                    Ptrapas_L, Ptrapac_L, Ptrapws_L, Ptrapwc_L, Ptrapis_L,
                    Ptrapic_L, Ptrapgs_L, Ptrapgc_L, Ptrapcs_L, Ptrapcc_L,
                    Pvalid, Pvalid_L, Fabs_B, Fabs_W, Fabs_L, Fabs_S, Fabs_D,
                    Fabs_X, Fabs_P, Fsabs_B, Fsabs_W, Fsabs_L, Fsabs_S, Fsabs_D,
                    Fsabs_X, Fsabs_P, Fdabs_B, Fdabs_W, Fdabs_L, Fdabs_S,
                    Fdabs_D, Fdabs_X, Fdabs_P, Facos_B, Facos_W, Facos_L,
                    Facos_S, Facos_D, Facos_X, Facos_P, Fsadd_B, Fsadd_W,
                    Fsadd_L, Fsadd_S, Fsadd_D, Fsadd_X, Fsadd_P, Fdadd_B,
                    Fdadd_W, Fdadd_L, Fdadd_S, Fdadd_D, Fdadd_X, Fdadd_P,
                    Fadd_B, Fadd_W, Fadd_L, Fadd_S, Fadd_D, Fadd_X, Fadd_P,
                    Fasin_B, Fasin_W, Fasin_L, Fasin_S, Fasin_D, Fasin_X,
                    Fasin_P, Fatan_B, Fatan_W, Fatan_L, Fatan_S, Fatan_D,
                    Fatan_X, Fatan_P, Fatanh_B, Fatanh_W, Fatanh_L, Fatanh_S,
                    Fatanh_D, Fatanh_X, Fatanh_P, Fbeq, Fbne, Fbgt, Fbngt, Fbge,
                    Fbnge, Fblt, Fbnlt, Fble, Fbnle, Fbgl, Fbngl, Fbgle, Fbngle,
                    Fbogt, Fbule, Fboge, Fbult, Fbolt, Fbuge, Fbole, Fbugt,
                    Fbogl, Fbueq, Fbor, Fbun, Fbf, Fbt, Fbsf, Fbst, Fbseq,
                    Fbsne, Fcmp_B, Fcmp_W, Fcmp_L, Fcmp_S, Fcmp_D, Fcmp_X,
                    Fcmp_P, Fcos_B, Fcos_W, Fcos_L, Fcos_S, Fcos_D, Fcos_X,
                    Fcos_P, Fcosh_B, Fcosh_W, Fcosh_L, Fcosh_S, Fcosh_D,
                    Fcosh_X, Fcosh_P, Fdbeq, Fdbne, Fdbgt, Fdbngt, Fdbge,
                    Fdbnge, Fdblt, Fdbnlt, Fdble, Fdbnle, Fdbgl, Fdbngl, Fdbgle,
                    Fdbngle, Fdbogt, Fdbule, Fdboge, Fdbult, Fdbolt, Fdbuge,
                    Fdbole, Fdbugt, Fdbogl, Fdbueq, Fdbor, Fdbun, Fdbf, Fdbt,
                    Fdbsf, Fdbst, Fdbseq, Fdbsne, Fdiv_B, Fdiv_W, Fdiv_L,
                    Fdiv_S, Fdiv_D, Fdiv_X, Fdiv_P, Fsdiv_B, Fsdiv_W, Fsdiv_L,
                    Fsdiv_S, Fsdiv_D, Fsdiv_X, Fsdiv_P, Fddiv_B, Fddiv_W,
                    Fddiv_L, Fddiv_S, Fddiv_D, Fddiv_X, Fddiv_P, Fetox_B,
                    Fetox_W, Fetox_L, Fetox_S, Fetox_D, Fetox_X, Fetox_P,
                    Fetoxm1_B, Fetoxm1_W, Fetoxm1_L, Fetoxm1_S, Fetoxm1_D,
                    Fetoxm1_X, Fetoxm1_P, Fgetexp_B, Fgetexp_W, Fgetexp_L,
                    Fgetexp_S, Fgetexp_D, Fgetexp_X, Fgetexp_P, Fgetman_B,
                    Fgetman_W, Fgetman_L, Fgetman_S, Fgetman_D, Fgetman_X,
                    Fgetman_P, Fint_B, Fint_W, Fint_L, Fint_S, Fint_D, Fint_X,
                    Fint_P, Fintrz_B, Fintrz_W, Fintrz_L, Fintrz_S, Fintrz_D,
                    Fintrz_X, Fintrz_P, Flog10_B, Flog10_W, Flog10_L, Flog10_S,
                    Flog10_D, Flog10_X, Flog10_P, Flog2_B, Flog2_W, Flog2_L,
                    Flog2_S, Flog2_D, Flog2_X, Flog2_P, Flogn_B, Flogn_W,
                    Flogn_L, Flogn_S, Flogn_D, Flogn_X, Flogn_P, Flognp1_B,
                    Flognp1_W, Flognp1_L, Flognp1_S, Flognp1_D, Flognp1_X,
                    Flognp1_P, Fmod_B, Fmod_W, Fmod_L, Fmod_S, Fmod_D, Fmod_X,
                    Fmod_P, Fsmove_B, Fsmove_W, Fsmove_L, Fsmove_S, Fsmove_D,
                    Fsmove_X, Fsmove_P, Fdmove_B, Fdmove_W, Fdmove_L, Fdmove_S,
                    Fdmove_D, Fdmove_X, Fdmove_P, Fmove_B, Fmove_W, Fmove_L,
                    Fmove_S, Fmove_D, Fmove_X, Fmove_P, Fmovecr_X, Fmovem_L,
                    Fmovem_X, Fsmul_B, Fsmul_W, Fsmul_L, Fsmul_S, Fsmul_D,
                    Fsmul_X, Fsmul_P, Fdmul_B, Fdmul_W, Fdmul_L, Fdmul_S,
                    Fdmul_D, Fdmul_X, Fdmul_P, Fmul_B, Fmul_W, Fmul_L, Fmul_S,
                    Fmul_D, Fmul_X, Fmul_P, Fsneg_B, Fsneg_W, Fsneg_L, Fsneg_S,
                    Fsneg_D, Fsneg_X, Fsneg_P, Fdneg_B, Fdneg_W, Fdneg_L,
                    Fdneg_S, Fdneg_D, Fdneg_X, Fdneg_P, Fneg_B, Fneg_W, Fneg_L,
                    Fneg_S, Fneg_D, Fneg_X, Fneg_P, Fnop, Frem_B, Frem_W,
                    Frem_L, Frem_S, Frem_D, Frem_X, Frem_P, Frestore, Fsave,
                    Fscale_B, Fscale_W, Fscale_L, Fscale_S, Fscale_D, Fscale_X,
                    Fscale_P, Fseq, Fsne, Fsgt, Fsngt, Fsge, Fsnge, Fslt, Fsnlt,
                    Fsle, Fsnle, Fsgl, Fsngl, Fsgle, Fsngle, Fsogt, Fsule,
                    Fsoge, Fsult, Fsolt, Fsuge, Fsole, Fsugt, Fsogl, Fsueq,
                    Fsor, Fsun, Fsf, Fst, Fssf, Fsst, Fsseq, Fssne, Fseq_B,
                    Fsne_B, Fsgt_B, Fsngt_B, Fsge_B, Fsnge_B, Fslt_B, Fsnlt_B,
                    Fsle_B, Fsnle_B, Fsgl_B, Fsngl_B, Fsgle_B, Fsngle_B,
                    Fsogt_B, Fsule_B, Fsoge_B, Fsult_B, Fsolt_B, Fsuge_B,
                    Fsole_B, Fsugt_B, Fsogl_B, Fsueq_B, Fsor_B, Fsun_B, Fsf_B,
                    Fst_B, Fssf_B, Fsst_B, Fsseq_B, Fssne_B, Fsgldiv_B,
                    Fsgldiv_W, Fsgldiv_L, Fsgldiv_S, Fsgldiv_D, Fsgldiv_X,
                    Fsgldiv_P, Fsglmul_B, Fsglmul_W, Fsglmul_L, Fsglmul_S,
                    Fsglmul_D, Fsglmul_X, Fsglmul_P, Fsin_B, Fsin_W, Fsin_L,
                    Fsin_S, Fsin_D, Fsin_X, Fsin_P, Fsincos_B, Fsincos_W,
                    Fsincos_L, Fsincos_S, Fsincos_D, Fsincos_X, Fsincos_P,
                    Fsinh_B, Fsinh_W, Fsinh_L, Fsinh_S, Fsinh_D, Fsinh_X,
                    Fsinh_P, Fssqrt_B, Fssqrt_W, Fssqrt_L, Fssqrt_S, Fssqrt_D,
                    Fssqrt_X, Fssqrt_P, Fdsqrt_B, Fdsqrt_W, Fdsqrt_L, Fdsqrt_S,
                    Fdsqrt_D, Fdsqrt_X, Fdsqrt_P, Fsqrt_B, Fsqrt_W, Fsqrt_L,
                    Fsqrt_S, Fsqrt_D, Fsqrt_X, Fsqrt_P, Fssub_B, Fssub_W,
                    Fssub_L, Fssub_S, Fssub_D, Fssub_X, Fssub_P, Fdsub_B,
                    Fdsub_W, Fdsub_L, Fdsub_S, Fdsub_D, Fdsub_X, Fdsub_P,
                    Fsub_B, Fsub_W, Fsub_L, Fsub_S, Fsub_D, Fsub_X, Fsub_P,
                    Ftan_B, Ftan_W, Ftan_L, Ftan_S, Ftan_D, Ftan_X, Ftan_P,
                    Ftanh_B, Ftanh_W, Ftanh_L, Ftanh_S, Ftanh_D, Ftanh_X,
                    Ftanh_P, Ftentox_B, Ftentox_W, Ftentox_L, Ftentox_S,
                    Ftentox_D, Ftentox_X, Ftentox_P, Ftrapeq, Ftrapne, Ftrapgt,
                    Ftrapngt, Ftrapge, Ftrapnge, Ftraplt, Ftrapnlt, Ftraple,
                    Ftrapnle, Ftrapgl, Ftrapngl, Ftrapgle, Ftrapngle, Ftrapogt,
                    Ftrapule, Ftrapoge, Ftrapult, Ftrapolt, Ftrapuge, Ftrapole,
                    Ftrapugt, Ftrapogl, Ftrapueq, Ftrapor, Ftrapun, Ftrapf,
                    Ftrapt, Ftrapsf, Ftrapst, Ftrapseq, Ftrapsne, Ftrapeq_W,
                    Ftrapne_W, Ftrapgt_W, Ftrapngt_W, Ftrapge_W, Ftrapnge_W,
                    Ftraplt_W, Ftrapnlt_W, Ftraple_W, Ftrapnle_W, Ftrapgl_W,
                    Ftrapngl_W, Ftrapgle_W, Ftrapngle_W, Ftrapogt_W, Ftrapule_W,
                    Ftrapoge_W, Ftrapult_W, Ftrapolt_W, Ftrapuge_W, Ftrapole_W,
                    Ftrapugt_W, Ftrapogl_W, Ftrapueq_W, Ftrapor_W, Ftrapun_W,
                    Ftrapf_W, Ftrapt_W, Ftrapsf_W, Ftrapst_W, Ftrapseq_W,
                    Ftrapsne_W, Ftrapeq_L, Ftrapne_L, Ftrapgt_L, Ftrapngt_L,
                    Ftrapge_L, Ftrapnge_L, Ftraplt_L, Ftrapnlt_L, Ftraple_L,
                    Ftrapnle_L, Ftrapgl_L, Ftrapngl_L, Ftrapgle_L, Ftrapngle_L,
                    Ftrapogt_L, Ftrapule_L, Ftrapoge_L, Ftrapult_L, Ftrapolt_L,
                    Ftrapuge_L, Ftrapole_L, Ftrapugt_L, Ftrapogl_L, Ftrapueq_L,
                    Ftrapor_L, Ftrapun_L, Ftrapf_L, Ftrapt_L, Ftrapsf_L,
                    Ftrapst_L, Ftrapseq_L, Ftrapsne_L, Ftst_B, Ftst_W, Ftst_L,
                    Ftst_S, Ftst_D, Ftst_X, Ftst_P, Ftwotox_B, Ftwotox_W,
                    Ftwotox_L, Ftwotox_S, Ftwotox_D, Ftwotox_X, Ftwotox_P);

    type Size is (Byte, Word, Long);

    type Operand is private;

    type Operand_Seq is array (Positive range <>) of Operand;
    N : Positive;

    --
    --  Instruction formats.
    --

    type Code_0 (Op : Opcode) is
        record
            null;
        end record;

    type Code_1 (Op : Opcode) is
        record
            Oprnd_1 : Operand;
        end record;

    type Code_2 (Op : Opcode) is
        record
            Oprnd_1 : Operand;
            Oprnd_2 : Operand;
        end record;

    type Code_3 (Op : Opcode) is
        record
            Oprnd_1 : Operand;
            Oprnd_2 : Operand;
            Oprnd_3 : Operand;
        end record;

    type Code_4 (Op : Opcode) is
        record
            Oprnd_1 : Operand;
            Oprnd_2 : Operand;
            Oprnd_3 : Operand;
            Oprnd_4 : Operand;
        end record;

    type Code_6 (Op : Opcode) is
        record
            Oprnd_1 : Operand;
            Oprnd_2 : Operand;
            Oprnd_3 : Operand;
            Oprnd_4 : Operand;
            Oprnd_5 : Operand;
            Oprnd_6 : Operand;
        end record;

    --
    --  Data formats.
    --

    type Data_1 (Sz : Size) is
        record
            Oprnd_1 : Operand;
        end record;

    type Data_N (Sz : Size) is
        record
            Oprnd_N : Operand_Seq (1 .. N);
        end record;

    --
    --  Call formats.
    --

    type Call_0 is
        record
            Subp : Operand;
        end record;

    type Call_1 is
        record
            Subp : Operand;
            Oprnd_1 : Operand;
        end record;

    type Call_N is
        record
            Subp : Operand;
            Oprnd_N : Operand_Seq (1 .. N);
        end record;

    --
    --  Registers.
    --

    D0 : constant Operand;
    D1 : constant Operand;
    D2 : constant Operand;
    D3 : constant Operand;
    D4 : constant Operand;
    D5 : constant Operand;
    D6 : constant Operand;
    D7 : constant Operand;

    A0 : constant Operand;
    A1 : constant Operand;
    A2 : constant Operand;
    A3 : constant Operand;
    A4 : constant Operand;
    A5 : constant Operand;
    A6 : constant Operand;
    A7 : constant Operand;

    Sp : constant Operand;

    -- Floating point registers.
    Fp0 : constant Operand;
    Fp1 : constant Operand;
    Fp2 : constant Operand;
    Fp3 : constant Operand;
    Fp4 : constant Operand;
    Fp5 : constant Operand;
    Fp6 : constant Operand;
    Fp7 : constant Operand;

    -- Status and Control registers.
    Pc : constant Operand;
    Sr : constant Operand;
    Ccr : constant Operand;
    Sfc : constant Operand;
    Dfc : constant Operand;
    Cacr : constant Operand;
    Usp : constant Operand;
    Vbr : constant Operand;
    Caar : constant Operand;
    Msp : constant Operand;
    Isp : constant Operand;

    -- Floating-point status registers.
    Fpcr : constant Operand;
    Fpsr : constant Operand;
    Fpiar : constant Operand;

    --  Suppresed registers.
    Zd0 : constant Operand;
    Zd1 : constant Operand;
    Zd2 : constant Operand;
    Zd3 : constant Operand;
    Zd4 : constant Operand;
    Zd5 : constant Operand;
    Zd6 : constant Operand;
    Zd7 : constant Operand;

    Za0 : constant Operand;
    Za1 : constant Operand;
    Za2 : constant Operand;
    Za3 : constant Operand;
    Za4 : constant Operand;
    Za5 : constant Operand;
    Za6 : constant Operand;
    Za7 : constant Operand;

    Zpc : constant Operand;

    --  MC68851 registers.
    Crp : constant Operand;
    Drp : constant Operand;
    Srp : constant Operand;
    Tc : constant Operand;
    Pcsr : constant Operand;
    Psr : constant Operand;
    Cal : constant Operand;
    Val : constant Operand;
    Sccr : constant Operand;
    Ac : constant Operand;
    Bad0 : constant Operand;
    Bad1 : constant Operand;
    Bad2 : constant Operand;
    Bad3 : constant Operand;
    Bad4 : constant Operand;
    Bad5 : constant Operand;
    Bad6 : constant Operand;
    Bad7 : constant Operand;
    Bac0 : constant Operand;
    Bac1 : constant Operand;
    Bac2 : constant Operand;
    Bac3 : constant Operand;
    Bac4 : constant Operand;
    Bac5 : constant Operand;
    Bac6 : constant Operand;
    Bac7 : constant Operand;

    Mmusr : constant Operand;  -- MC68030 psr
    Tt0 : constant Operand;  -- MC68030
    Tt1 : constant Operand;  -- MC68030

    Itt0 : constant Operand;  -- MC68040
    Itt1 : constant Operand;  -- MC68040
    Dtt0 : constant Operand;  -- MC68040
    Dtt1 : constant Operand;  -- MC68040
    Urp : constant Operand;  -- MC68040

    Nc : constant Operand;  -- MC68040 CINV/CPUSH no cache
    Dc : constant Operand;  -- MC68040 CINV/CPUSH data cache
    Ic : constant Operand;  -- MC68040 CINV/CPUSH instruction cache
    Bc : constant Operand;  -- MC68040 CINV/CPUSH data & instruction cache

    --
    --  MC68881 on-chip ROM offsets.
    --

    Pi : constant := 16#00#;
    Log10_2 : constant := 16#0B#;
    E : constant := 16#0C#;
    Log2_E : constant := 16#0D#;
    Log10_E : constant := 16#0E#;
    Zero : constant := 16#0F#;
    Ln_2 : constant := 16#30#;
    Ln_10 : constant := 16#31#;
    Tene0 : constant := 16#32#;
    Tene1 : constant := 16#33#;
    Tene2 : constant := 16#34#;
    Tene4 : constant := 16#35#;
    Tene8 : constant := 16#36#;
    Tene16 : constant := 16#37#;
    Tene32 : constant := 16#38#;
    Tene64 : constant := 16#39#;
    Tene128 : constant := 16#3A#;
    Tene256 : constant := 16#3B#;
    Tene512 : constant := 16#3C#;
    Tene1024 : constant := 16#3D#;
    Tene2048 : constant := 16#3E#;
    Tene4096 : constant := 16#3F#;

    --
    --  Addressing modes.
    --

    function W return Size renames Word;
    function L return Size renames Long;

    function Indr (Addr_Reg : Operand) return Operand;

    -- Assembler Notation:
    --   (An)
    --
    -- Description:
    --   The address of the operand is in the address register specified
    --   by the register field.

    function Incr (Addr_Reg : Operand) return Operand;

    -- Assembler Notation:
    --   (An)+
    --
    -- Description:
    --   The address of the operand is in the address register specified
    --   by the register field.  After the operand address is used, it is
    --   incremented by one, two, or four depending upon whether the size
    --   of the operand is byte, word, or long word.  If the address register
    --   is the stack pointer and the operand size is byte, the address is
    --   incremented by two rather than one to keep the stack pointer on a
    --   word boundary.

    function Decr (Addr_Reg : Operand) return Operand;

    -- Assembler Notation:
    --   -(An)
    --
    -- Description:
    --   The address of the operand is in the address register specified
    --   by the register field.  Before the operand address is used, it is
    --   decremented by one, two, or four depending upon whether the size
    --   of the operand is byte, word, or long word.  If the address register
    --   is the stack pointer and the operand size is byte, the address is
    --   decremented by two rather than one to keep the stack pointer on a
    --   word boundary.

    function Disp (Reg : Operand; Int : Integer) return Operand;

    function Disp (Reg : Operand; Lab : Operand) return Operand;

    -- Assembler Notation:
    --   d(An)
    --   d(PC)
    --
    -- Description:
    --   The address of the operand is the sum of the address in the address
    --   register or PC and the sign-extended 16-bit displacement.

    function Index (Reg : Operand;
                    Int : Integer;
                    Index_Reg : Operand;
                    Index_Size : Size;
                    Scale : Integer := 1) return Operand;

    function Index (Reg : Operand;
                    Lab : Operand;
                    Index_Reg : Operand;
                    Index_Size : Size;
                    Scale : Integer := 1) return Operand;

    -- Assembler Notation:
    --   d(An, Rn.SIZE*SCALE)
    --   d(PC, Rn.SIZE*SCALE)
    --
    -- Description:
    --   The address of the operand is the sum of the address in the address
    --   register or PC, the 8-bit displacement, and the contents of the
    --   index register (possibly scaled).

    function Memory (Pre_Mem : Operand; Od : Integer := 0) return Operand;

    -- Assembler Notation:
    --   ([bd,An,Ri.SIZE{*SCALE}],od)
    --   ([bd,PC,Ri.SIZE{*SCALE}],od)
    --
    -- Description:
    --   The address of the operand is the sum of the pre_mem and a sign-
    --   extended outer displacement value od.  pre_mem is the sum of the
    --   contents of the address register An (or ZAn), the base displacement,
    --   and the contents of the index register Ri (or ZRi).

    function Memory (Post_Mem : Operand;
                     Index_Reg : Operand;
                     Index_Size : Size;
                     Scale : Integer := 1;
                     Od : Integer := 0) return Operand;

    -- Assembler Notation:
    --   ([bd,An],od,Ri.SIZE{*SCALE})
    --   ([bd,PC],od,Ri.SIZE{*SCALE})
    --
    -- Description:
    --   The address of the operand is the sum of the post_mem, the contents
    --   of the index register Ri (or ZRi), and the outer displacement value
    --   od.  post_mem is the sum of the base displacement and the contents
    --   of the the base register An (or ZAn).

    function Absol (Addr : Integer; Addr_Size : Size) return Operand;

    -- Assembler Notation:
    --   xxx.W
    --   xxx.L
    --
    -- Description:
    --   The address of the operand is given.

    function Immed (Val : Integer) return Operand;

    function Immed (Val : Float) return Operand;

    function Immed (Val : Character) return Operand;

    function "+" (Right : Integer) return Operand;

    function "-" (Right : Integer) return Operand;

    function "+" (Right : Float) return Operand;

    function "-" (Right : Float) return Operand;

    function "/" (Left : Operand; Right : Operand) return Operand;

    -- Assembler Notation:
    --   <list>
    --
    -- Description:
    --   A list of any combination of registers to form a mask.
    --   May only be used in the 'movem' and 'fmovem' instructions.

    function Ext (Name : String; Disp : Integer := 0) return Operand;

    -- Assembler Notation:
    --   name
    --
    -- Description:
    --   The name denotes an external symbol.  The displacement is added to
    --   the value of name.

    function "-" (Left, Right : Operand) return Operand;

    -- Description:
    --   Calculates the difference between two labels.

private

    --
    --  Implementation specific.
    --

    for Size use (Byte => 8, Word => 16, Long => 32);

    type Operand is new Integer;

    D0 : constant Operand := 0;
    D1 : constant Operand := 1;
    D2 : constant Operand := 2;
    D3 : constant Operand := 3;
    D4 : constant Operand := 4;
    D5 : constant Operand := 5;
    D6 : constant Operand := 6;
    D7 : constant Operand := 7;

    A0 : constant Operand := 8;
    A1 : constant Operand := 9;
    A2 : constant Operand := 10;
    A3 : constant Operand := 11;
    A4 : constant Operand := 12;
    A5 : constant Operand := 13;
    A6 : constant Operand := 14;
    A7 : constant Operand := 15;

    Sp : constant Operand := A7;

    Fp0 : constant Operand := 16;
    Fp1 : constant Operand := 17;
    Fp2 : constant Operand := 18;
    Fp3 : constant Operand := 19;
    Fp4 : constant Operand := 20;
    Fp5 : constant Operand := 21;
    Fp6 : constant Operand := 22;
    Fp7 : constant Operand := 23;

    Pc : constant Operand := 24;
    Sr : constant Operand := 25;
    Ccr : constant Operand := 26;
    Sfc : constant Operand := 27;
    Dfc : constant Operand := 28;
    Cacr : constant Operand := 29;
    Usp : constant Operand := 30;
    Vbr : constant Operand := 31;
    Caar : constant Operand := 32;
    Msp : constant Operand := 33;
    Isp : constant Operand := 34;
    Fpcr : constant Operand := 35;
    Fpsr : constant Operand := 36;
    Fpiar : constant Operand := 37;

    Zd0 : constant Operand := 38;
    Zd1 : constant Operand := 38;
    Zd2 : constant Operand := 38;
    Zd3 : constant Operand := 38;
    Zd4 : constant Operand := 38;
    Zd5 : constant Operand := 38;
    Zd6 : constant Operand := 38;
    Zd7 : constant Operand := 38;

    Za0 : constant Operand := 38;
    Za1 : constant Operand := 38;
    Za2 : constant Operand := 38;
    Za3 : constant Operand := 38;
    Za4 : constant Operand := 38;
    Za5 : constant Operand := 38;
    Za6 : constant Operand := 38;
    Za7 : constant Operand := 38;

    Zpc : constant Operand := 39;

    Crp : constant Operand := 40;
    Drp : constant Operand := 41;
    Srp : constant Operand := 42;
    Tc : constant Operand := 43;
    Pcsr : constant Operand := 44;
    Psr : constant Operand := 45;
    Cal : constant Operand := 46;
    Val : constant Operand := 47;
    Sccr : constant Operand := 48;
    Ac : constant Operand := 49;
    Bad0 : constant Operand := 50;
    Bad1 : constant Operand := 51;
    Bad2 : constant Operand := 52;
    Bad3 : constant Operand := 53;
    Bad4 : constant Operand := 54;
    Bad5 : constant Operand := 55;
    Bad6 : constant Operand := 56;
    Bad7 : constant Operand := 57;
    Bac0 : constant Operand := 58;
    Bac1 : constant Operand := 59;
    Bac2 : constant Operand := 60;
    Bac3 : constant Operand := 61;
    Bac4 : constant Operand := 62;
    Bac5 : constant Operand := 63;
    Bac6 : constant Operand := 64;
    Bac7 : constant Operand := 65;

    Tt0 : constant Operand := 66;
    Tt1 : constant Operand := 67;

    Itt0 : constant Operand := 68;
    Itt1 : constant Operand := 69;
    Dtt0 : constant Operand := 70;
    Dtt1 : constant Operand := 71;
    Urp : constant Operand := 72;
    Mmusr : constant Operand := 73;

    Nc : constant Operand := 76;  -- MC68040 CINV/CPUSH no cache
    Dc : constant Operand := 77;  -- MC68040 CINV/CPUSH data cache
    Ic : constant Operand := 78;  -- MC68040 CINV/CPUSH instruction cache
    Bc : constant Operand := 79;  -- MC68040 CINV/CPUSH data & instruction cache

end Machine_Code;

pragma Built_In (Machine_Code);