Ygthkb

Some subroutine calls on PDP-11 machines would be coded with the arguments appearing immediately after JSR or EMT instruction, something like this (apologies for not knowing the exact MACRO syntax):

    jsr r5,WRITE_STRING

    .byte 'This is some string'.'0'

continue:

    ; do stuff

    rts pc



WRITE_STRING:

    movb (r5)+,r0

    beq  done

    .PRINT r0

    br   WRITE_STRING

done:

    inc r5

    bic #1,r5

    jmp (r5)

The jsr instruction sets r5 to point to the beginning of an ASCIZ string that is located in-line in the code, right after the jsr. The WRITE_STRING subroutine then reads the bytes pointed to by r5 and prints them out until the terminating zero is found. r5 is then aligned property, and control is returned to the caller with jmp (r5).

There were variants of this calling conventions; for instance the arguments could be indirect, in which case pointers to the actual arguments would be inlined in code, rather than the arguments themselves.

Was there a name for this in-line argument technique?

The older PDP-8 did similar.  It had only one register to speak of (the accumulator), so a subroutine that took several parameters would typically provide a set of values and/or pointers to values immediately after the call instruction (JMS).  The called routine would increment the return address to access parameters, and finally to return to the caller just after the parameter block.

This text describes the parameter passing as "in-line":
https://people.cs.clemson.edu/~mark/subroutines/pdp8.html.

The PDP-8 handbook "Introduction to Programming", January 1969, page 3-19, item #6 describes it simply with the following:

The second number to be multiplied is brought into the subroutine by the TAD I MULT instruction since it is stored in the location specified by the address that the JMS instruction automatically stores in the first location of the subroutine [i.e. the return address].  This is a common technique for transferring information to a subroutine.

The first instruction of a subroutine was where the return address is stored by the JMS instruction.  Thus, this word was used to pick up parameters as well as to return to the function's caller.  The PDP-8 had fixed size instructions and data words of 12-bits (word addressing only); it also supported a memory indirect addressing mode, and a memory increment operation, so this approach worked fairly well.

I do not know any specific name here. It was usually called a 'Parameter List'.

It may be due the fact, that this way was more on less the standard handling on many early systems supporting subroutine calls. The need of special names usually only arises when additional methods come into use.

It's inherent benefit is that no additional parameter register is needed, as the return address is stored in the link register, which than can double as parameter list pointer, only to be advanced while processing, and at the end holding the return address (after the parameter list) (*1). For mainframe systems it was the standard calling convention.

Using the stack for return address handling is a rather new development - compared with parameter passing - but even then it was used quite a lot. Just think the way OS calls (*2) are made in Apple ProDOS.

*1 - In fact, it wouldn't at all be wired to think of it as a stack pointer to access (and pop) the parameters - and when all parameters are removed it holds the return address.

*2 - MLI or Machine Language Interface in ProDOS lingua. Here a the JSR to $BF00, the ProDOS entry point, is followed by a byte defining the function call and a word holding the address of a parameter block for this function.