Possibility set ADL offset for non-ADL code

[nihirash]

Sometimes, if you're writing code for legacy mode, you'll need use prefixed commands like LD.LIL for example:

ld.lil hl, (dma_ptr)

And current version will built binary with zero offset but MOS applications use $40000 base offset for all addresses and some of my code works in next page(with base offset $50000).

Currently, I'm using workaround with adding numeric constant for basic address offset like:

ld.lil hl, ($50000 + dma_ptr)

But if we'll introduce possibility compile non ADL programs with specified MB-offset - it will be great!

[envenomator]

The LD.LIL HL, (Mmn) opcode expects a 24-bit address to access the ADL space outside the non-ADL boundary of 64KB that the assembler works with in non-ADL mode.

[envenomator]

It's up to the programmer to specify an outside address, potentially derived from an outside-of-the assembler source.
However, it looks like you're trying to build a larger than 64KB binary, loaded by MOS as non-ADL mode and still reference data in that same binary in memory using the ADL statement.
Creating a 'mode' that requires checking every label statement AND they way it is used (adl/non-adl) for such a specific case; is that what you are asking?
I'm pretty sure this will have significant performance impact during assembly

[nihirash]

Let me show you on example: https://github.com/nihirash/ZINC/

I'm working on CP/M emulation layer for MOS and you can check my code 😸

For example, if I'll make something like(src/edos/edos.asm):

    ASSUME ADL=1
    org $5f000
    ASSUME ADL=0

It should work as I expect but it breaks on function table in edos/core.asm(cause addresses are 24 bit already and too large to fit into word-sized var).

Why I need ADL pointers? Cause MOS still have ADL only functions in file api and I need to provide full 24-bit address for them like for fread/fwrite(edos/disk.asm).

I'll be glad to any solution if it will make my code less magical.

But if it'll break usual use cases - I can keep this parts the same as now.

[envenomator]

I'm sure that your ask is legitimate, however it's still not clear to me what exactly it is you are asking.
It's a lot to ask anyone to 'check my code' to get an understanding of what they are actually asking. I've even perused some of it, but it's still not clear to me.

[nihirash]

I need compile non ADL code with possibility use full prefixed full addressing commands(like here: https://github.com/nihirash/ZINC/blob/1ef1c1025fac78c328a38a7c74e3ee31378b39ac/src/edos/disk.asm#L209 )

I've spend some time with thinking about it and found that best way will be allow truncating addresses in ADL=0 mode to words(for this: https://github.com/nihirash/ZINC/blob/1ef1c1025fac78c328a38a7c74e3ee31378b39ac/src/edos/core.asm#L72 usage).

You can produce warning about truncating value to just 16 bit but allow storing them as words(in ADL=0 mode at least).

If I'll specify in ADL=1 mode full address obviously - it will be correct way to use it in prefixed mode and don't produce corner cases.

And after switching ADL off, I'd like have possibility store 16 bit pointers to links(warning here is ok).

For making things a bit more clear I've prepared isolated test-case:

    ASSUME ADL=1
    org $50100 ;; Setting address EXPLICITLY in ADL mode with MB page 

    ASSUME ADL=0 ;; Going to ADL off mode
start:
    ld.lil hl, test ;; Loading HL  with full address $5xxxx - this works fine here!
    ret

;; But I need use function table
fun_table:
    dw fun1 ;; Here should be 16 bit address $xxxx possibly with warning that address was truncated to 16 bits
    dw fun2 ;; but now compilations is failed
    dw fun3 ;; 

fun1:
    ld hl, 1
    ret

fun2:
    ld bc, 1
    ret

fun3:
    ld hl, 3
    ret
    
test:
    db "Hello"

Sorry for unclear explanation

[envenomator]

I think I understand what you are trying to do.
Normal immediate emission at an opcode doesn't even check the length in ADL=0, so for example LD HL,0xffffff in ADL=0 produces 0xffff as immediate after the 0x21 opcode without a warning currently.
The only place where I'm checking for the length of a value is in either DW or BLK*, which is what you need for the jumptable.

Let me ponder how to best approach this

[envenomator]

fixed in 24b86a9

[nihirash]

Fix confirmed!