Just to give some more explanations:
we have at our site some macros, which allow the structuring of large
ASSEMBLER programs in subroutines. There is a mainline, which is
started by a startup macro (let's call it PSTART), which does all the
linkage
conventions and establishes some base registers for the code and
data area. The number of base registers for the code area is not limited,
but normally should not exceed 3, that makes a code area of 12 k.
The registers may be specified on the PSTART macro call.
Then there are subroutine macros, let's say PPROC and PEND.
PPROC establishes two registers for the code area, which limits
each "PROC" to 8k. Again, the registers may be specified on the
the PPROC macro call.
Of course, the registers may be reused for every new PROC. So already
in the past, programs of virtually umlimited size were possible.
Each PROC can have "local" variables that are located behind the
PEND macro and are accessible only from this PROC.
Now:
By converting the PPROC and PEND macros (and all other macros)
to "baseless", I was able to remove the 8k restriction for the PPROC / PEND
blocks, and I only needed one base register, because I didn't need to
cover the code area any more; I only covered the static data area
behind the PEND macro (and limited it to 4k in the normal case).
The code area may grow without limit, as long as the relativ branches
reach their targets.
I hope this gives you an idea what I did when I converted our environment
to "baseless".
Kind regards
Bernd
Am 06.12.2013 15:45, schrieb Scott Ford:
Bernd,
Ty for your thread. Some of us unfortunately work in multiple languages are of
course are getting older, so we may have to ask about a design or concept more
than once..yes I am older and I have a condition which makes focusing sometimes
difficult...
That being said, my reason for baseless code is eliminating multiple base
register usage and maintain ability..am I wrong here ?
Scott ford
www.identityforge.com
from my IPAD
'Infinite wisdom through infinite means'
On Dec 6, 2013, at 9:20 AM, Bernd Oppolzer <[email protected]> wrote:
Cross-Posted to IBM-Main and IBM-ASSEMBLER-List
I believe it has been discussed before:
the term "baseless programming" is an over-simplification.
It should be "an ASSEMBLER programming technique, where the
code area is not covered by base registers" - which requires
separation of code area and data area and relative branch instructions;
take care of your literals.
If you have large code areas, this may save you some registers,
or you may save some time otherwise needed to save and reload
the registers which cover the code area.
I managed to convert most of our inhouse macros in the last few months
to "baseless", including the site-specific SP macros, so now I don't have
restrictions regarding the size of the code areas any more. Of course,
it is not good to have large code areas (small functional blocks are better),
but if you want to add trace output macros or other test facilities to a
functional block, you don't like it if code area size restrictions prevent you
from doing it. This was the main reason for my "baseless" effort - I had
to do some maintenance to some very large and very old programs, and
the only way to do it was to add some trace output.
Thanks to Ed Jaffe for the link to the SHARE presentation, BTW.
Kind regards
Bernd
----------------------------------------------------------------------
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to [email protected] with the message: INFO IBM-MAIN
----------------------------------------------------------------------
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to [email protected] with the message: INFO IBM-MAIN
