Feature request: passing address hi/lo in registers to inline asm

[gergoerdi]

In assembly, I can use the handy < and > syntax to refer to the high and low byte of an address. However, if the address comes from outside the asm block, it still needs to be taken apart manually.

Here's an example:

void k_setnam(const char *fname)
{
    uint8_t len = strlen(fname);
    uint16_t ptr = (uint16_t)(fname);
    uint8_t ptrlo = (uint8_t)(ptr);
    uint8_t ptrhi = (uint8_t)(ptr >> 8);

    __attribute__((leaf)) asm volatile(
        "jsr $ffbd"
        : "+a" (len), "+x" (ptrlo), "+y" (ptrhi)
        :
        : "p"
        );
}

Based on the insight in #84, I should be able to rewrite this as:

void k_setnam(const char *fname)
{
    uint8_t len = strlen(fname);
    uint16_t ptr = (uint16_t)(fname);
    uint8_t ptrlo = (uint8_t)(ptr);
    uint8_t ptrhi = (uint8_t)(ptr >> 8);

    __attribute__((leaf)) asm volatile(
        "jsr $ffbd"
        : 
        : "a" (len), "x" (ptrlo), "y" (ptrhi)
        : "p"
        );
}

but what I'd really like to write is something like

void k_setnam(const char *fname)
{
    __attribute__((leaf)) asm volatile(
        "jsr $ffbd"
        : 
        : "a" ((uint8_t)(strlen(fname)), "xy" (fname)
        : "p"
        );
}

or some other similarly concise syntax.

[mysterymath]

I took a quick look at doing this, but it doesn't look particularly feasible without rewriting a portion of LLVM's inline assembly lowering or doing some massive hacks. It presently assumes that each constraint is assigned to either a single register or a sequence of registers from the same register class, which doesn't permit the kind of free-wheeling splitting requested in the PR.

It should be fairly easy to work around this though, either by hand or with compiler macros. Accordingly, I'm deprioritizing this one.

[mysterymath]

Closing as won't fix; it's just too difficult to do this for what's gained.