IBM Mainframe Forum

Hello friends,

I trying compare two DC. But i getting S0C1.. I don't know what is wrong, I was debugging many of hours but still same issue..

Where to start?
1. You do not set up a proper base register
2. you have a second using 'USING *,R2'. My assembler throws a warning,I believe yours do too?
3. you load r3 from where r2 points to, which is x'00000000' as you just cleared r2 and set it as base.
4. your use of r0 as index and length don't make any sense'
But your 0C1 is caused by the ' BNE EXIT1 ' because r2 is defined as you base and contains zeroes so you are jumping to low core.

I strongly suggest that you find a proper manual with some good samples.

Ok, just this once, but the sample is really not much use. For starters it does not set it's own save area.

Mr. Jensen is correct about the save area, but as you have discovered from trying Mr. Jensen's example it is not always necessary to obtain a new save area.

As written Mr. Jensen's program is guilty of one minor sin. It saves and restores too many registers. It does not use registers 2, 3, 4, 5, 6, 7, 8, 9, 10 and 11. Saving and restoring registers is the most expensive part of program linkage. In this program register 2 is a better candidate for the base register: the SAVE and RETURN macros store the registers in order starting with register 14, so it saves them in the order 14, 15, 0, ... 12. Specify SAVE (14,2) and RETURN (14,2) to save and restore just 5 registers rather than 15. You won't really see anything here, but if you should run this code millions of times you will see a difference

Your use of CLC is fine for equal / not equal, but if you need less than or greater than CLC won't work reliably.
Many people discourage using the so called linkage registers (registers 0, 1, 14 and 15), but they are great when you need registers for just a couple of instructions like here.

Finally, what is this MF= stuff on the WTO macros? There are two parts of a traditional WTO macro: the code to send the message to the system, and the message. In WTO 'message' both parts are combined into one code block, but it is possible to separate them. WTO MF=(E,message) just creates the code to send the message to the system, and MF=L defines the message.

Hello Mr. Jensen, hello Mr. Myers,

my main problem is that i don't understand what is base-register. I read many web pages where is explanation of base registr.. But still I don’t know for what is useful this register.

Yes, my compilator was have RC 4.. But I ignore it, because of many examples it was same situation.. I was think that is ok..

Thank you again for explanation. Today I will try write again anything and I will see. I must understand base register. Your code is very useful for me. I hope that I not get S0C1 when I will try to run him..

But still I don’t know for what is useful this register.

In order to access memory (L, ST, CLC instructions for example), you must be able to address it -- which merely means you have to know its address (memory starts at byte 0 and goes through whatever the highest byte is). A base register establishes a base address and memory access instructions will then use an offset from the base register to determine the memory address of a particular byte. In classic assembler, a base register can be used to access up to 4096 bytes of memory (the offset is 3 bytes so X'000' through X'FFF' are the possible offsets).in this line from an assembly, the operation code is 41, the register being loaded is 2, there is no offset from register 2 (hence 0), the address of VALUE1 is X'060' from the base register which is 15 (X'F').

The first computer I used, back when dinosaurs really did rule was the IBM 7040. The 7040 was the trailing end of a computer architecture that started back in the dim mists of (almost) pre history when the switching circuits were ruled by vacuum tubes. One of the important reasons for the success (140 were made) of the 704 was its gigantic (for the day) 32K words of memory. No doubt there were people wondering how they could use all that memory!

There were two problems that ultimately led to the collapsed of the architecture. By the early 1960s it was clear much, much more memory would be required in the future. There were one off extensions that got 64K words of memory using bank switching, but, at best, this is a terribly clumsy way to add memory. The other problem is each instruction that addressed memory had a 15 bit field with the storage address of the data. Every time a program was loaded into memory these data addresses had to be relocated to contain the actual storage address of the data the instruction used. This was painfully slow.

Now, let's look at a System/360 program.

In this program SAVE and RETURN are macro calls: a "macro" is instructions to the Assembler (the program that translates source code to binary data for the computer) to generate addition code. This SAVE macro just generates one real instruction: STM 14,2,12(13). The convention in System/360 is register 13 contains the address of a save area, which is just a data area used to store registers.

BALR 2,0
USING *,2
LA 15,SAVEAREA
ST 13,4(,15)
ST 15,8(,13)
LR 13,15

The BALR instruction is normally used to call another program: this BALR instruction stores the address of the next instruction in register 2, but it does not actually go to another program because register 0 cannot be used for that purpose.

The USING instruction is a directive to the Assembler program. The USING instruction is the programmer promising the Assembler program that register 2 contains the current address.

LA 15,SAVEAREA

The LA (Load Address) instruction is a machine instruction that tells the computer to compute the address of SAVEAREA. 41F0201E is the binary data that the computer uses. 41 is the data the computer interprets as Load Address. F is register 15, where the computer will store the address, and 201E is the "address;" 2 is register 2, the base register, and 01E is the factor to add to the base register. The 01E was calculated by the Assembler program by using the address supplied by the USING instruction and the data address, 00024, supplied by the programmer and effectively determined by the Assembler: 24 - 6 = 01E. Back in 1968, when I understood what was going on I immediately saw 2 advantages compared to the IBM 704 tradition. First, the base register had a much larger potential address than the measly 32K of the 704. The second is once calculated by the Assembler this 01E was fixed. The system could load the program anywhere in storage without altering anything in the program.

The Assembler program is wonderfully flexible. You can specify the base register and offset directly without making the Assembler compute the offset. This is what ST 13,4(,15) is doing.

Many instructions do not require the Assembler (or the machine) to compute an address: this is what the BALR and LR instructions do in our little program.

Nothing is "free" in this scheme. Most instructions require the computer to do arithmetic to compute a data address in every instruction, and this has the effect that the computer runs slower. Perhaps 10 years later when virtual memory came in you had nay sayers grumbling about the computational cost of the extra arithmetic required under the covers for the virtual memory to work.

see here

http://simotime.com/indexasm.htm

program is guilty of one minor sin. It saves and restores too many registers

Untill the day when you use one more register in your program and forget to change the SAVE or the RETURN. I prefer to stick with the defined standard. Then again, with assembler you are supposed to know what you are doing. Just be careful.

willy jensen wrote:... I prefer to stick with the defined standard. ...

SAVE (14,12) is hardly a "defined standard." It's what instructors established 50+ years ago. The best that can be said for it is it's reliable.

willy jensen wrote:...Just be careful.

No argument. I have a small, semi standardized, internal process that I typically write from scratch in many programs. It's roughly one page. It starts with SAVE (14,4). Now that's fine. The register usage is dead on. But all to often, out of habit, I write RETURN (14,12) at the end. Oops.

IBM spent I don't know how many millions developing XPLINK, in part because SAVE (14,12) / RETURN (14,12) sucked up too many cycles and IBM got caught when the LE standard which uses, in effect, SAVE (14,12) / RETURN (14,12), was adopted in the C++ environment. This is a lesson that applies to all of us.