Conference turris::macro

    Re: .0
    
    Jayna, you need to post the calling Fortran source .. (cut it
    down to the smallest self-contained unit which will demonstrate the
    problem) .. and the compilation and link commands used.
    
    John.

    John, please excuse the delay in followup -- Jayna's out the office on
    sick leave.  I've attached the requested info to the end of this
    message.  
    
    Thanks in advance,
    Mary
    
    SUMMARY:  On OpenVMS Alpha V6.2, the attached MACRO routine
    successfully executes calls to ADDD2 and MULTD3.  On V7.1, the same
    routine eventually fails with an ACCVIO when calling MULD3.  The
    customer has worked around the problem by substituting ADDG2 and MULG3.
    
    $ run/nodeb mxm			! V6.2
    
    *** Multiply two matrices ***
    
    Matrix A entered:
      2.0000000000000000       4.0000000000000000       6.0000000000000000
    
    Matrix B entered:
      4.0000000000000000
      8.0000000000000000
     12.0000000000000000
    
    Product:
    112.0000000000000000
    
    $ run/nodeb mxm			! V7.1
    
    *** Multiply two matrices ***
    
    Matrix A entered:
      2.0000000000000000       4.0000000000000000       6.0000000000000000
    
    Matrix B entered:
      4.0000000000000000
      8.0000000000000000
     12.0000000000000000
    %SYSTEM-F-ACCVIO, access violation, reason mask=00, 
       virtual address=0000000000000001, PC=0000000000030FF8, 
       PS=0000001B
    %TRACE-F-TRACEBACK, symbolic stack dump follows
    image    module    routine            line      rel PC           abs PC
    MXM  AMAC_FLT_D_FORMAT  amac_flt_muld  409 00000000000005A8 0000000000030FF8
    MXM  UUTMTMPY8  UUTMTMPY8               29 00000000000000F8 00000000000300F8
    MXM  MXM$MAIN  MXM$MAIN                 51 00000000000005D8 00000000000308A8
                                             0 FFFFFFFF887BB0D8 FFFFFFFF887BB0D8
    

    NOTE:  An image linked on V7.1 will fail on either V6.2 or V7.1, and 
    an image linked on V6.2 will execute successfully on V6.2 or V7.1.  
    
    ************************************************************
    Execute this procedure to reproduce:

$ CREATE MXM.FOR
    
      IMPLICIT NONE
      INTEGER ERCODE, INUNIT
      INTEGER I, J, N, M, L, NROWA, NCOLA, NROWB, NCOLB, MAXDIM
      PARAMETER (MAXDIM = 6)
      REAL*8 ROW(MAXDIM)
      REAL*8 A(MAXDIM,MAXDIM), B(MAXDIM,MAXDIM), C(MAXDIM,MAXDIM)
      CHARACTER*80 LINE1, LINE2

C     Initialize the arrays:
      DO I=1,MAXDIM
        DO J=1,MAXDIM
          A(I,J) = 0.0
          B(I,J) = 0.0
          C(I,J) = 0.0
        ENDDO
      ENDDO
      PRINT '(/, A)', ' *** Multiply two matrices ***'

C     Number of Columns in Matrix A must = Number of Rows in Matrix B
      NROWA = 1
      NCOLA = 3
      DO I=1, NCOLA
	A(NROWA, I) = 2*I
      ENDDO

      NROWB = 3
      NCOLB = 1
      DO I=1, NROWB
        B(I, NCOLB) = 4*I
      ENDDO

C     Display the input data:

      PRINT '(/, A)', ' Matrix A entered:'

      DO I=1,NROWA
        WRITE(*, 500) (A(I,J), J=1,NCOLA)
      ENDDO

      PRINT '(/, A)', ' Matrix B entered:'
      DO I=1,NROWB
        WRITE(*, 500) (B(I,J), J=1,NCOLB)
      ENDDO

C     Compute the product (using full-blown, MAXDIM x MAXDIM matrices!):
      N = MAXDIM    !<-- # rows in A.
      M = MAXDIM    !<-- # columns in A (or rows in B).
      L = MAXDIM    !<-- # columns in B.

      CALL UUTMTMPY8(A, B, C, N, M, L)

C     Display the product matrix:
      PRINT '(/, A)', ' Product:'
      DO I=1,NROWA
        WRITE(*, 500) (C(I,J), J=1,NCOLB)
      ENDDO

C     STOP
C  FORMAT statement:

500   FORMAT(1X, 6(F20.16, 5X))
      END
    
$ CREATE UUTMTMPY8.MAR
         .TITLE UUTMTMPY8
         .PSECT $LOCAL,PIC,USR,CON,NOSHR,RD,WRT,LCL,REL,NOEXE,LONG,NOVEC
OCTR:    .LONG
MCTR:    .LONG
;
;
;
         .PSECT $CODE,PIC,CON,REL,LCL,SHR,EXE,RD,NOWRT,LONG
         .ENTRY UUTMTMPY8,^M<R2,R3,R4,R5,R6,R7,R8,R9,R10,R11>
A=4
B=8
C=12
N=16
M=20
L=24
         MOVL   @N(AP),R11      ;INDEX INCREMENT FOR B
         MOVL   A(AP),R0        ;BASE ADDRESS FOR A
         MOVL   C(AP),R2        ;BASE ADDRESS FOR C
         CMPL   @L(AP),#1       ; IS L INDEX A ONE?
         BEQL   ONE
         MOVL   R11,OCTR        ;INIT OUTER LOOP COUNTER TO N
OUTER:   CLRL   R4              ;INIT INDEX FOR B
         CLRL   R5              ;INIT INDEX FOR C
         MOVL   @L(AP),MCTR     ;INIT MIDDLE LOOP COUNTER
MIDDLE:  CLRL   R3              ;INIT INDEX FOR A
         MOVL   B(AP),R1        ;INIT BASE ADDRESS FOR B
         CLRQ   R9              ;CLEAR SUM
         MOVL   @M(AP),R8       ;INIT INNER LOOP COUNTER
INNER:   MULD3  (R0)[R3],(R1)+[R4],R6   ;MULTIPLY A*B=TEMP
         ADDD2  R6,R9           ;ADD TO SUM
         ADDL2  R11,R3          ;INCREMENT A INDEX (COLUMN)
         SOBGTR R8,INNER
         MOVQ   R9,(R2)[R5]     ;STORE SUM IN C
         ADDL2  R11,R5          ;INCREMENT C INDEX
         ADDL2  @M(AP),R4       ;INCREMENT B INDEX
         SOBGTR MCTR,MIDDLE
         ADDL2  #8,R0           ;INCREMENT BASE FOR A
         ADDL2  #8,R2           ;INCREMENT BASE FOR C
         SOBGTR OCTR,OUTER
         RET
ONE:     MOVL   R11,R4          ;INIT OUTER LOOP COUNTER
         MOVL   @M(AP),R5       ;INIT INNER LOOP COUNTER
OUT:     CLRL   R3              ;INIT INDEX FOR A
         MOVL   B(AP),R1        ;INIT BASE ADDRESS FOR B
         CLRQ   R9              ;CLEAR SUM
         MOVL   R5,R8           ;INIT INNER LOOP COUNTER
INN:     MULD3  (R0)[R3],(R1)+,R6   ;MULTIPLY A*B=TEMP
         ADDD2  R6,R9           ;ADD TO SUM
         ADDL2  R11,R3          ;INCREMENT A INDEX (COLUMN)
         SOBGTR R8,INN
         MOVQ   R9,(R2)         ;STORE SUM IN C
         ADDL2  #8,R0           ;INCREMENT BASE FOR A
         ADDL2  #8,R2           ;INCREMENT BASE FOR C
         SOBGTR R4,OUT
         RET
         .END

$ fort /deb/noopt /float=D_FLOAT /noalign /vms /warn=noalign -
    	/ass=dummy MXM.FOR
$ mac /noopt /debug UUTMTMPY8.MAR
$ link /deb /exe=MXM.EXE MXM,UUTMTMPY8
$ run MXM

Well, in this case, the routine that makes up the
instruction ADDD2 r6,r9 is not preserving
the value of R1; which in of itself is correct.
However, the MACRO compiler is not noticing this
and fails to restore R1 after the 'instruction'.

Since this address is used in the MULD3 call
the second loop of INNER fails with the ACCVIO
error.