?login_element?

Subversion Repositories NedoOS

Rev

Rev 1132 | Blame | Compare with Previous | Last modification | View Log | Download

  1.        macro ADDRr8 ;r/m register
  2. ;a=r/m byte (kept)
  3.        ld l,a
  4.        res 6,l
  5.        ld h,_AX/256
  6.        ld l,(hl) ;rm addr
  7.        endm
  8.         macro ADDRr16_keepa ;r/m register
  9. ;a=r/m byte
  10.         ld h,a
  11.         and 7
  12.         add a,a
  13.         ld l,a
  14.         ld a,h
  15.         ld h,_AX/256
  16.         endm
  17.         macro ADDRr16_nokeepa ;r/m register
  18. ;a=r/m byte
  19.         and 7
  20.         add a,a
  21.         ld l,a
  22.         ld h,_AX/256
  23.         endm
  24.  
  25.         macro GETr16
  26.         ld c,(hl)
  27.         inc l
  28.         ld b,(hl)
  29.         endm
  30.         macro GETr16_de
  31.         ld e,(hl)
  32.         inc l
  33.         ld d,(hl)
  34.         endm
  35.         macro GETr16_hl
  36.         ld b,(hl)
  37.         inc l
  38.         ld h,(hl)
  39.         ld l,b
  40.         endm
  41.  
  42.        macro SWAPr16
  43.         ld a,(hl)
  44.         ld (hl),c
  45.         ld c,a
  46.         inc l
  47.         ld a,(hl)
  48.         ld (hl),b
  49.         ld b,a
  50.         ld a,l
  51.         cp 1+(_SP&0xff)
  52.         call z,encodeSP_pp
  53.        endm
  54.  
  55.         macro _PUTr8Loop_
  56. ;hl is kept since ADDRr8
  57.         ld (hl),a
  58.        _Loop_
  59.         endm
  60.  
  61.         macro _PUTr16Loop_
  62. ;hl is kept since ADDRr16
  63. ;bc=data
  64.         ld a,l
  65.         _PUTr16Loop_AisL
  66.         endm
  67.         macro _PUTr16Loop_AisL
  68.         ld (hl),c
  69.         inc l
  70.         ld (hl),b
  71.         cp _SP&0xff
  72.         jp z,encodeSPLoop ;TODO ret z
  73.        _Loop_
  74.         endm
  75.  
  76.         macro _PUTr16LoopC
  77. ;hl is kept since ADDRr16
  78. ;bc=data
  79.         ld a,l
  80.         _PUTr16LoopC_AisL
  81.         endm
  82.         macro _PUTr16LoopC_AisL
  83.         ld (hl),c
  84.         inc l
  85.         ld (hl),b
  86.         cp _SP&0xff
  87.         jp z,encodeSPLoopC ;TODO ret z
  88.        _LoopC
  89.         endm
  90.  
  91.         macro _PUTr16hlLoop_
  92. ;(sp)=ADDRr16
  93. ;hl=data
  94.         pop bc
  95.         ld a,l
  96.         ld (bc),a
  97.         inc c
  98.         ld a,h
  99.         ld (bc),a
  100.         ld a,c
  101.         cp 1+(_SP&0xff)
  102.         jp z,encodeSPhlLoop ;TODO ret z
  103.        _Loop_
  104.         endm
  105.  
  106. encodeSP_pp
  107.         ld hl,(_SP)
  108.         encodeSP
  109.         ret
  110.  
  111. encodeSPLoop
  112. encodeSPLoopC
  113.         ld h,b
  114.         ld l,c
  115. encodeSPhlLoop
  116.         encodeSP
  117.        _LoopC
  118.  
  119.         macro ADDRSEGMENT_chl_bHSB
  120. ;hl=addr
  121. ;abc=?s*16
  122.         ADDSEGMENT_hl_abc_to_ahl
  123.         ld c,a
  124.         ld a,h
  125.         or 0xc0
  126.         ld h,a
  127. ;c=page (%01..5432)
  128.         endm
  129.  
  130.         macro GETm16
  131.           ;ld b,tpgs/256
  132.           ;ld a,(bc)
  133.           ;SETPGC000
  134.         ld a,(hl)
  135.         inc l
  136.         call z,inch_nextsubsegment_pglx
  137.         ld b,(hl)
  138.         ld c,a
  139.         endm
  140.  
  141.         macro ADDRm16_GETm8b_keepaf ;for MOVr8rmmem, OPr8rmmem, TESTrmmemr8, CMPrmmemr8 (в CMPrmmemi8 GET_PUTm8 и pop af)
  142.         push af
  143.         call ADDRGETm16_pp
  144.         ;ADDRSEGMENT_chl_bHSB
  145.         ;ld b,tpgs/256
  146.         ;ld a,(bc)
  147.         ;SETPGC000
  148.         pop af
  149.         ld b,(hl)
  150.         endm
  151.  
  152.         macro ADDRm16_GETm8c_for_PUTm8 ;for OPrmmemi8/r8, ROLm8... ;keep lx=pg!!! ;TODO kill
  153.         push af
  154.         call ADDRGETm16_pp
  155.         ;ADDRSEGMENT_chl_bHSB
  156.         ; ld lx,c
  157.         ;ld b,tpgs/256
  158.         ;ld a,(bc)
  159.         ;SETPGC000
  160.         pop af
  161.         ld c,(hl)
  162.         endm
  163.  
  164.         macro ADDRm16_for_PUTm8a_nokeepaf ;for MOVrmmemi8, MOVrmmemr8
  165.         call ADDRGETm16_pp
  166.         ;ADDRSEGMENT_chl_bHSB
  167.         ; ld lx,c
  168.         ;ld b,tpgs/256
  169.         ;ld a,(bc)
  170.         ;SETPGC000
  171.         endm
  172.  
  173.         macro ADDRm16_GETm16 ;for MOVr16rmmem, MOVsregrmmem, CMPrmr16, OPr16rmmem, TESTrmmemr16
  174.         push af
  175.         call ADDRGETm16_pp
  176.         ;ADDRSEGMENT_chl_bHSB
  177.             ;ld lx,c ;можно убрать, если особый вариант nextsubsegment
  178.          GETm16
  179.         pop af
  180.         endm
  181.  
  182.         macro ADDRm16_GETm16_keeplx ;for 32bit read
  183.         push af
  184.         call ADDRGETm16_pp
  185.         ;ADDRSEGMENT_chl_bHSB
  186.         ; ld lx,c
  187.          GETm16
  188.         pop af
  189.         endm
  190.  
  191.         macro ADDRm16_GETm16_keeplx_nokeepaf ;for 32bit read
  192.         call ADDRGETm16_pp
  193.         ;ADDRSEGMENT_chl_bHSB
  194.         ; ld lx,c
  195.          GETm16
  196.         endm
  197.  
  198.         macro ADDRm16_for_PUTm16_nokeepaf ;for MOVrmmemi16, POPrm16
  199.         call ADDRGETm16_pp
  200.         ;ADDRSEGMENT_chl_bHSB
  201.         ; ld lx,c
  202.         endm
  203.  
  204.         macro ADDRm16_for_PUTm16 ;for MOVrmmemr16/sreg
  205.          push af
  206.         call ADDRGETm16_pp
  207.         ;ADDRSEGMENT_chl_bHSB
  208.         ; ld lx,c
  209.          pop af
  210.         endm
  211. ;TODO fix! уже прочитано 2 байта из (hl)!
  212.  
  213.         macro ADDRm16_GETm16_for_PUTm16 ;for OPrmmemi16/r16, ROLm16..., TESTrmmemi16, MULrmmem16...
  214.        push af
  215.         call ADDRGETm16_pp
  216.         ;ADDRSEGMENT_chl_bHSB
  217.         ; ld lx,c
  218.         push hl
  219.         GETm16
  220.         pop hl ;TODO
  221.        pop af ;;TODO a проносить в hx, pop hl убрать, т.к. далее обычно стоит push hl
  222.         endm
  223.  
  224.         macro skip2b_GETm16
  225.        ld c,lx
  226.         ld b,tpgs/256
  227.         ld a,(bc)
  228.         SETPGC000
  229.         inc l
  230.         call z,inch_nextsubsegment_pglx
  231.         inc l
  232.         call z,inch_nextsubsegment_pglx
  233.         ld a,(hl)
  234.         inc l
  235.         call z,inch_nextsubsegment_pglx
  236.         ld b,(hl)
  237.         ld c,a
  238.         endm
  239.  
  240.         macro _PUTm8aLoopC_oldpglx
  241. ;hl=addr
  242. ;a=data
  243. ;lx=page (%01..5432)
  244.         ld (hl),a
  245.         ld c,lx
  246.        _PUTscreen_logpgc_zxaddrhl_datamhl
  247.        _LoopC
  248.         endm
  249.  
  250.         macro _PUTm8cLoopC_oldpglx
  251. ;hl=addr
  252. ;c=data
  253. ;lx=page (%01..5432)
  254.         ld (hl),c
  255.         ld c,lx
  256.        _PUTscreen_logpgc_zxaddrhl_datamhl
  257.        _LoopC
  258.         endm
  259.  
  260.         macro _PUTm16_oldpglx
  261. ;hl=addr
  262. ;bc=data
  263. ;lx=pg
  264.         ld (hl),c ;TODO записать в память второй байт заранее (а сложная ветка только при hl=0xffff)
  265.         push bc
  266.          ld c,lx
  267.        _PUTscreen_logpgc_zxaddrhl_datamhl_keephlpg ;TODO по умолчанию без keeppg и сразу 2 байта
  268.         inc l
  269.         call z,inch_nextsubsegment_pglx
  270.         pop af
  271.         ld (hl),a
  272.          ld c,lx
  273.        _PUTscreen_logpgc_zxaddrhl_datamhl ;TODO убрать там повторный ld c,lx:ld b,.../256
  274.        ;_LoopC
  275.         endm
  276.  
  277.         macro _PUTm16LoopC
  278. ;hl=addr
  279. ;bc=data
  280. ;lx=pg
  281.        push bc ;bc=data
  282.          ld c,lx
  283.          ld b,tpgs/256
  284.          ld a,(bc)
  285.         SETPGC000
  286.        pop bc ;bc=data
  287.        _PUTm16_oldpglx
  288.        _LoopC
  289.         endm
  290.  
  291.         macro _PUTm16hlLoopC ;(instead of ld b,h:ld c,l:pop hl:_PUTm16LoopC)
  292. ;(sp)=addr
  293. ;hl=data
  294. ;lx=pg
  295.        ex (sp),hl ;hl=addr, (sp)=data
  296.          ld c,lx
  297.          ld b,tpgs/256
  298.          ld a,(bc)
  299.         SETPGC000
  300.        pop bc ;bc=data
  301.        _PUTm16_oldpglx
  302.        _LoopC
  303.         endm
  304.  
  305. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  306.  
  307. ADDRm16_pp_ssbp_plusi ;ss:bp+?i+
  308.         ld bc,(_BP)
  309.         add hl,bc
  310.        cp 64
  311.        ret c
  312. ADDRm16_pp_ssbp ;ss:bp+ ;не бывает nodisp, отсеяно выше
  313. ;MD=01: cmd [...+disp8]
  314. ;MD=10: cmd [...+disp16]
  315.        rla
  316.         get ;dispL
  317.         next
  318.        jr nc,ADDRm16_pp_ds_8bit
  319.         add a,l
  320.         ld l,a
  321.         jr nc,$+3
  322.         inc h
  323.         get ;dispH
  324.         next
  325.         add a,h
  326.         ld h,a
  327.         ret
  328.  
  329. ;000=[bx]+[si]+disp
  330. ;001=[bx]+[di]+disp
  331. ;010=[bp]+[si]+disp
  332. ;011=[bp]+[di]+disp
  333. ;100=[si]+disp
  334. ;101=[di]+disp
  335. ;110=[bp]+disp ;за исключением случая mod=00 и rm=110, когда EA равен старшему и младшему байтам смещения
  336. ;111=[bx]+disp
  337. ;a=r/m byte
  338. ;out (only for LEA): hl=addr
  339. ADDRm16_pp
  340.         bit 2,a
  341.         jr z,ADDRm16_pp_sum ;ds:b?+?i+
  342. ;1xx
  343.         bit 1,a
  344.         jr z,ADDRm16_pp_i ;ds:?i+
  345. ;11x
  346.         bit 0,a
  347.         ld hl,(_BX)
  348.         jr nz,ADDRm16_pp_ds ;ds:??+
  349.         ld hl,(_BP)
  350.        cp 64
  351.        jr nc,ADDRm16_pp_ssbp ;ss:bp+
  352. ;[bp+nodisp] = [disp]
  353.        getHL
  354.         ret
  355. ADDRm16_pp_i ;10x
  356.         bit 0,a
  357.         ld hl,(_SI)
  358.         jr z,ADDRm16_pp_ds
  359.         ld hl,(_DI)
  360.         jp ADDRm16_pp_ds
  361. ADDRm16_pp_sum ;0xx
  362.         bit 0,a
  363.         ld hl,(_SI)
  364.         jr z,$+5
  365.         ld hl,(_DI)
  366.         bit 1,a
  367.         jp nz,ADDRm16_pp_ssbp_plusi;01?=[bp]+[?i]+disp
  368.         ld bc,(_BX) ;00?=[bx]+[?i]+disp
  369.         add hl,bc
  370. ADDRm16_pp_ds ;ds:??+
  371. ;MD=00: cmd [...] ;no disp
  372.        cp 64
  373.        ret c
  374. ;MD=01: cmd [...+disp8]
  375. ;MD=10: cmd [...+disp16]
  376.        rla
  377.         get ;dispL
  378.         next
  379.        jr nc,ADDRm16_pp_ds_8bit
  380.         add a,l
  381.         ld l,a
  382.         jr nc,$+3
  383.         inc h
  384.         get ;dispH
  385.         next
  386.         add a,h
  387.         ld h,a
  388.         ret
  389. ADDRm16_pp_ds_8bit
  390.        or a
  391.        jp p,$+4
  392.        dec h
  393.         add a,l
  394.         ld l,a
  395.         ret nc
  396.         inc h
  397.         ret
  398.  
  399. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  400.  
  401. ADDRGETm16_pp_ssbp_plusi ;ss:bp+?i+
  402.        push bc
  403.         ld bc,(_BP)
  404.         add hl,bc
  405.        pop bc
  406.        cp 64
  407.        jr c,ADDRGETm16_pp_ss_nodisp
  408. ADDRGETm16_pp_ssbp ;ss:bp+ ;не бывает nodisp, отсеяно выше
  409. ;MD=01: cmd [...+disp8]
  410. ;MD=10: cmd [...+disp16]
  411.        rla
  412.         get ;dispL
  413.         next
  414.        jr nc,ADDRGETm16_pp_ssbp_8bit
  415.         add a,l
  416.         ld l,a
  417.         jr nc,$+3
  418.         inc h
  419.        ;bit 7,c
  420.        ;jr z,ADDRGETm16_pp_ss_nodisp
  421.         get ;dispH
  422.         next
  423.         add a,h
  424.         ld h,a
  425. ADDRGETm16_pp_ss_nodisp
  426.         bit 0,b
  427.         jr nz,ADDRGETm16_pp_segprefix
  428.         ld bc,(ss_LSW)
  429.         ld a,(ss_HSB)
  430.         ADDRSEGMENT_chl_bHSB
  431.          ld lx,c
  432.         ld b,tpgs/256
  433.         ld a,(bc)
  434.         SETPGC000
  435.         ret
  436. ADDRGETm16_pp_ssbp_8bit
  437.        or a
  438.        jp p,$+4
  439.        dec h
  440.         add a,l
  441.         ld l,a
  442.         jr nc,ADDRGETm16_pp_ss_nodisp
  443.         inc h
  444.         jp ADDRGETm16_pp_ss_nodisp
  445.  
  446. ;000=[bx]+[si]+disp
  447. ;001=[bx]+[di]+disp
  448. ;010=[bp]+[si]+disp
  449. ;011=[bp]+[di]+disp
  450. ;100=[si]+disp
  451. ;101=[di]+disp
  452. ;110=[bp]+disp ;за исключением случая mod=00 и rm=110, когда EA равен старшему и младшему байтам смещения
  453. ;111=[bx]+disp
  454. ;a=r/m byte
  455. ;b=?s_LSW+1 (если нечётный, а иначе сегмент по умолчанию)
  456. ;out: hl=zxaddr, lx=page on (%01..5432) [b=?s_HSB]
  457. ADDRGETm16_pp
  458.         bit 2,a
  459.         jr z,ADDRGETm16_pp_sum ;ds:b?+?i+
  460. ;1xx
  461.         bit 1,a
  462.         jr z,ADDRGETm16_pp_i ;ds:?i+
  463. ;11x
  464.         bit 0,a
  465.         ld hl,(_BX)
  466.         jr nz,ADDRGETm16_pp_ds ;ds:??+
  467.         ld hl,(_BP)
  468.        cp 64
  469.        jr nc,ADDRGETm16_pp_ssbp ;ss:bp+
  470. ;[bp+nodisp] = [disp]
  471.        getHL
  472.         bit 0,b
  473.         jr z,ADDRGETm16_pp_seg_ds
  474. ADDRGETm16_pp_segprefix
  475.         push hl
  476.         ld h,es_LSW/256
  477.         ld l,b
  478.         ld b,(hl)
  479.         dec l
  480.         ld c,(hl)
  481.         res 4,l
  482.         ld a,(hl)
  483.         pop hl ;abc=?s*16
  484.         ADDRSEGMENT_chl_bHSB
  485.          ld lx,c
  486.         ld b,tpgs/256
  487.         ld a,(bc)
  488.         SETPGC000
  489.         ret
  490. ADDRGETm16_pp_i ;10x
  491.         bit 0,a
  492.         ld hl,(_SI)
  493.         jr z,ADDRGETm16_pp_ds
  494.         ld hl,(_DI)
  495.         jp ADDRGETm16_pp_ds
  496. ADDRGETm16_pp_sum ;0xx
  497.         bit 0,a
  498.         ld hl,(_SI)
  499.         jr z,$+5
  500.         ld hl,(_DI)
  501.         bit 1,a
  502.         jp nz,ADDRGETm16_pp_ssbp_plusi;01?=[bp]+[?i]+disp
  503.        push bc
  504.         ld bc,(_BX) ;00?=[bx]+[?i]+disp
  505.         add hl,bc
  506.        pop bc
  507. ADDRGETm16_pp_ds ;ds:??+
  508. ;MD=00: cmd [...] ;no disp
  509.        cp 64
  510.        jr c,ADDRGETm16_pp_ds_nodisp
  511. ;MD=01: cmd [...+disp8]
  512. ;MD=10: cmd [...+disp16]
  513.        rla
  514.         get ;dispL
  515.         next
  516.        jr nc,ADDRGETm16_pp_ds_8bit
  517.         add a,l
  518.         ld l,a
  519.         jr nc,$+3
  520.         inc h
  521.         get ;dispH
  522.         next
  523.         add a,h
  524.         ld h,a
  525. ADDRGETm16_pp_ds_nodisp
  526. ;вызывается из MOVaxmem
  527. ;out: hl=zxaddr, c=page (%01..5432), [b=?s_HSB]
  528.         bit 0,b
  529.         jr nz,ADDRGETm16_pp_segprefix
  530. ADDRGETm16_pp_seg_ds
  531.         ld bc,(ds_LSW)
  532.         ld a,(ds_HSB)
  533.         ADDRSEGMENT_chl_bHSB
  534.          ld lx,c
  535.         ld b,tpgs/256
  536.         ld a,(bc)
  537.         SETPGC000
  538.         ret
  539. ADDRGETm16_pp_ds_8bit
  540.        or a
  541.        jp p,$+4
  542.        dec h
  543.         add a,l
  544.         ld l,a
  545.         jr nc,ADDRGETm16_pp_ds_nodisp
  546.         inc h
  547.         jp ADDRGETm16_pp_ds_nodisp
  548.  
  549. inch_nextsubsegment_pglx
  550. ;lx=page (%01..5432) ;keep updated for GET..PUT back
  551. ;keep a
  552. ;hl=0xXX00 ;keep updated
  553.         inc h
  554.         ret nz
  555.        push af
  556.         ld a,lx
  557.         add a,64
  558.         adc a,0
  559.         ld lx,a
  560.         ld c,a ;c=page (%01..5432)
  561.        ;dec a
  562.        ;cp b ;b=?s_HSB
  563.        ;jr nz,$+3
  564.        ;dec c ;если читать слово из [?s:ffff], то второй байт читается из [?s:0000], но на 386 не так
  565.         ld b,tpgs/256
  566.         ld a,(bc)
  567.         SETPGC000
  568.         ld h,0xc0
  569.        pop af
  570.         ret
  571.