IBM Assembler Interview Questions And Answers

ICM means INsert character under mask. its a movement of character under mask bits
eg
ICM R8,B'0110',SRC

Before execution:
R8 ==> 12 34 56 78
SRC ==> AB CD EF 10

After Excecution:
R8 ==> 12 CD EF 78

If you write an MVC statement with an equated value as the
sending operand, then the assembler will try to resolve that
operand value as a base and displacement, it will not
necessarily throw an error at assembly, but the results at
execution will be unpredictable and may well give rise to a
protection exception.
The point of the MVI statement is that the single byte
sending operand value is assembled as part of the
instruction itself and does not have to be 'fetched' at
execution time, therefore if you are only moving a single
byte of fixed value, then an MVI will be marginally more
efficient than an MVC

Use Accept in procedure division.
Example :
WORKING-STORAGE SECTION.
01 empno. Pic x(05).
01 empname pic x(15).
01 empsal pic 9(10).
PROCEDURE DIVISION.
................
PERFORM ACCEPT-PARA.
..............
ACCEPT-PARA.
ACCEPT EMPNO.
ACCEPT EMPNAME.
ACCEPT EMPSAL.

In JCL :
...........
............
//sysin dd *
001
aaaa
330000
/*

R1 contains a fullword that contains a address pointing to
tyhe parm data. In pgm before accessing the parm data use L
Rn,0(,R1) where n=3,..11 , Rn contains the address that
points to parm data. Create DSECT that contains a halfword
and the length of the data.

It will give an error at the time of assembly, if there are
some labels defined in the program(provided they are being
referenced in your program). This is because the assembler
resolves the displacement of that variable from the location
where your base register is pointing to.

it all depends upon the length of your program , if it is
more than 4095 then we need 2 register else only one can do
needful.
basically we can even use savearea register as a base
register, so as to accomodate the length of the program

In MVS assembler data type X denotes hexadecimal data type
which unsigned pack. suppose you define VAR1 as "VAR1 DC
X'01'". It will occupy 1 byte in the memory and stored as:
0 in the zoned nibble and 1 in the numeric nibble.

P denotes the packed data type, similar to COMP-3 in COBOL.
if you declare any variable with this data type then it
must have a sign byte at last nibble. See following example:
VAR2 DC P'1'
it will occupy one byte in the memory and stored as '1C'.

neither DROP nor USING affect the register contents.
Once a register has been loaded with the address of a piece
of storage, the using statement can be used to 'map' that
storage against a set of labels defining the layout of that
storage e.g. a DSECT. Then whenever one of those labels is
referenced in the code, in moves etc, the assembler resolves
the relative address as a particular displacement from the
absolute address in the register. The DROP instruction
removes the relationship between the labels and the register
and renders subsequent references to those labels as
unresolvable, giving rise to errors at assembly (compile)time.
Typically the DROP instruction will be used to allow use of
the register for another purpose, e.g. address a different
bit of storage via a using staement on second DSECT without
the risk of corrupting that data via moves referencing the
original DSECT.

XR Rx,Rx

This is the best way and most efficient way of initializing
the register values or Label values to '0'.

Its because the time required to execute a Logical
Instruction is always less than the Arithmetic Instructions.

e.g SR Rx,Rx consumes more execution time than XR Rx,Rx.

So XR Rx,Rx is a better way to do obtain our target.

House keeping is used to store the contents of the base
register from one register to another for using that
register.

These are house keeping instructions where contents of the
registers are stored
1. content of the register 15 is stored in the register 12
2. address in reg 12 is mapped to the module type
3. save area is stored in the register 13

A base register is any general purpose register chosen by
programmer. It is assigned at the beginning of the program
as part of housekeeping with the USING assembler keyword,
and it's purpose is to maintain addressibility within a
page (4k) of code or data.

Lenght feild is 8 bits so the data is stored in binary
format so if we have all 8 bits set to 1 then the length
will be 128+64+32+16+8+4+2+1 = 255.or
2^7+ 2^6+2^5...2^0 = 255.

so the lenght is 256 .

By convention, general purpose register 1 will have the
address of the parameter list. The list will be a list of
pointers (addresses) to individual parameters. The CALL
macro does this, but you can bypass the CALL macro and be
creative on how you set up the parameter list. Don't forget
the parameter must be on a fullword boundary.

for example we want to test if given variable is numeric we can do it by following code.

We can define a table with all FF execpt from 0 t0 9 00

Table1 DC 256c'ff'
org table1
dc 10c'00'

Now we can give
TRT var1,table1
BZ numeric

START is an assembler directive which has an optional
operand, (0 in your example). This operand acts as the
starting address of the program e.g. PROGNAME START X'3E0'
tells the linkage editor that this program is to be loaded
into main storage at address '3E0' in hex. This explanation
answers all your questions.

This is a vague two-part question.
1) You can round by adding .5
2) Adds 5 to WKUR, but it had better be a valid packed field, and not just a label.

There are 16 registers, and ALL can be used as a base EXCEPT
for register 0, so the answer is AT LEAST 15. AT LEAST is
specified here because in any section of code, you can
"re-use" a previous base register once you are no longer
within the original address range ("scope") of that
particular base register. By re-using the registers, you can
have base registers that will cover ALL of the memory in the
machine - but not all at once - you have to "bite off" 15
base reg-at-a-time chunks of memory (all addressable memory
does not have to be contiguous - it can be scattered around
memory in 4K pieces).

You will need to open de file SYSIN via a DCB and read the
data via GET commands. The data in the PARM field is passed
via register 1. Any dataset you want to use in Assembler
you will need to open. There are no automatic allocation.

We can certainly use the MVC instruction to move the pack data to another pack field.

since the machine-code for MVC moves up to 256 bytes, you would need to do a series of MVCs to initialize 20000 bytes. this requires that you maintain a register or two to keep track of how far you've progressed through initialization.

possibly, you could get MVCL to do it; i've never tried...

MVCL uses 2 sets of even-odd pairs of registers to do the move.
you specify source address, destination address, length of source, length of destination, and fill character in the registers. the fill-character goes into the high order byte of (I THINK...) the destination length register (in this case r4)
l r4,=f'20000'
l r6,=f'20000'
la r7,source_field
la r5,dest_field
mvcl r4,r6

As this is mainframe assembler section, this is a trick
question - there is no JMPNZ opcode for mainframe (recently
added JNZ with relative addressing in the z/800 and later,
but no JMPNZ) and the mainframe has no RET instruction
(there is a PR to return from a cross address space or PC
"call" statement) and the mainframe has no accumulator, ADB
opcode, or B register.

There are two possible scenarios:
1) This is a classroom quesiton where you are expected to
do some research on your own, and not ask someone in the
cloud for the exact answer.
2) The question is too vague, and would require a full
essay to answer. Please be more specific.

Registers are part of the CPU logic and should not be
confused with memory real or virtual. The question is
about as sensical as asking where the uterus resides in a
man. Also, general purpose registers 0--16 are an
entirely different breed that the floating point
registers. As for the numbering, a decision made by the
manufacturer's design people.

S0C7 occurs when the data exception occurs.They are many
ways to produce S0C7

1)Move non numeric data to a numeric feild
2)compare junk data with a numeric feild
3) Use a non numeric data in COMPUTE statement
4) Refer to the occurence in a table beyond the occurs time
with SSRANGE not checked in complier options

VSAM file can be accessed through an Assembler application
program by using assembler macros RPL, ACB