Oppolzer - Informatik / Blog

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 S.F.:
> 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 ?
>
> S. F.
>
> 'Infinite wisdom through infinite means'
>
>
>> On Dec 6, 2013, at 9:20 AM, Bernd Oppolzer <bernd.oppolzer@T-ONLINE.DE> 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 E.J. for the link to the SHARE presentation, BTW.
>>
>> Kind regards
>>
>> Bernd
>>
>>
>>
>> ----------------------------------------------------------------------
>> For IBM-MAIN subscribe / signoff / archive access instructions,
>> send email to listserv@listserv.ua.edu with the message: INFO IBM-MAIN
>>