ASMB,R,L,C,Z HED (FMP) IDMEM: LOCATE REAL-TIME MEMORY CONFLICTS * NAME: IDMEM * SOURCE: 92071-18061 * RELOC: 92071-16061 * PGMR: M.L.K. * MOD: E.D.B. * * *************************************************************** * * (C) COPYRIGHT HEWLETT-PACKARD COMPANY 1980. ALL RIGHTS * * * RESERVED. NO PART OF THIS PROGRAM MAY BE PHOTOCOPIED, * * * REPRODUCED OR TRANSLATED TO ANOTHER PROGRAM LANGUAGE WITHOUT* * * THE PRIOR WRITTEN CONSENT OF HEWLETT-PACKARD COMPANY. * * *************************************************************** * * NAM IDMEM,7 92071-1X061 REV.2041 800409 * ENT IDMEM * EXT .ENTR IFN *** L/10 CODE *** EXT $FWRT, $FWBG, $BGBP, $ID#, $IDA, $IDSZ XIF SUP SKP * * DESCRIPTION * * THIS MODULE WILL FIND ANY REAL-TIME PROGRAM WHOSE MEMORY * BOUNDS CONFLICT IN ANY WAY WITH THE MEMORY BOUNDS PASSED TO * IT. IT IS USED TO DETERMINE IF THERE EXITS A REAL TIME * PROGRAM WHOSE MEMORY BOUNDS WOULD CONFLICT WITH ONE WHICH IS * BEING SET UP BY RP. * * CALLING SEQUENCE: * * IADDR = IDMEM(IADBF) * * WHERE: * * IADBF = POINTER TO A SKELETON ID SEGMENT FROM * A TYPE 6 FILE * * IDADR = 0 IF NO CONFLICT OR NOT A REAL-TIME PROGRAM * ID SEGMENT ADDRESS OF NAME OF CONFLICTING * PROGRAM * * SPECIAL ASSEMBLY INSTRUCTIONS: * THIS FILE CONTAINS SOURCE CODE FOR BOTH THE RTE-L AND RTE-L/20 * IDMEM ROUTINES. ASSEMBLE THE CODE WITH THE N OPTION TO CREATE * THE RTE-L VERSION, AND WITH THE Z OPTION TO CREATE THE RTE-L/20 * VERSION. SKP * * ENTRY * NUID NOP * IDMEM NOP JSB .ENTR SET UP PARAMETERS DEF NUID * IFN *** L/10 CODE *** LDA $FWBG GET FIRST WORD OF BACKGROUND CMA,INA COMPLEMENT AND SAVE STA FWBG FOR REAL TIME/BACKGROUND TEST * * SET UP NEW ADDRESSES FROM CALLER'S ID SEGMENT * LDB NUID GET ID ADDRESS ADB .20 POINT TO WORD 21 LDA B,I GET NEW LOW MAIN STA NULO AND SAVE IT * ADB .3 NOW POINT TO WORD 24 LDA B,I AND GET LOW BASE PAGE AND B1777 AND ISOLATE IT STA NULOB STORE IT * ADB .9 POINT TO WORD 33. LOADER SET THIS LDA B,I TO HIGHEST PROGRAM ADDRESS + 1 ADA N1 SUBTRACT 1 FOR HIGHEST ADDRESS STA NUHI SAVE IT * INB NOW POINT TO WORD 34. LOADR SETS THIS LDA B,I TO HIGH BP ADDRESS + 1 ADA N1 SUBTRACT 1 FOR HIGHEST BP ADDRESS STA NUHIB AND SAVE * * CHECK IF THIS IS A REAL-TIME PROGRAM * LDA NULO TEST IF THE LOW BOUND IS IN JSB BCHEK REAL-TIME AREA. IF SO, ASSUME DEF $FWRT+0 THE LOADR HAS CHECKED THE REST DEF $FWBG+0 OF THE BOUNDARIES SZA,RSS REAL-TIME? JMP EXIT NO, EXIT OK. SKP * * INITIALIZE LOOP * LDA $ID# GET NUMBER OF ID SEGMENTS CMA,INA SET IT NEGATIVE STA COUNT AND SAVE FOR LOOP COUNT * LDA $IDA GET ADDRESS OF FIRST ID ADA .12 AND POINT TO NAME (FOR ACTIVE CHECK) STA IDPTR AND SAVE ID POINTER SKP * * TEST ID * LOOP LDB IDPTR,I GET FIRST NAME WORD SZB,RSS IF IT IS 0, THE ID NOT USED JMP NEXT NOT IN USE, DO NEXT * LDB IDPTR SET UP ID'S BOUNDS ADB .8 POINT TO LOW MAIN LDA B,I GET ADDRESS FROM ID STA MLO AND SAVE IN MAIN LOW ADA FWBG ADD THE NEGATIVE FIRST WORD OF BACKGROUND SSA,RSS THIS ID RT OR BG? JMP NEXT BG, SKIP IT, CAN'T CONFLICT * INB POINT TO HIGH MAIN+1 LDA B,I GET ADDRESS FROM ID STA MHI AND SAVE IN MAIN HIGH * ADB .2 POINT TO LOW BASE PAGE/#SEGMENTS LDA B,I GET ADDRESS FROM ID AND B1777 ISOLATE LOW BASE PAGE STA BLO SAVE IN BASE PAGE LOW LDA B,I GET WORD AGAIN ALF,ALF POSITION # OF SEGMENTS RAR,RAR TO LOW BITS AND B77 AND ISOLATE STA NUMSG SAVE NUMBER OF SEGMENTS * INB POINT TO HIGH BASE PAGE LDA B,I GET ADDRESS FROM ID AND B1777 ISOLATE ADDRESS STA BHI SAVE IN BASE PAGE HIGH * LDA NUMSG GET NUMBER OF SEGMENTS SZA,RSS SEGMENTED? JMP CKBND NO, CHECK MEMORY BOUNDS * LDA $FWBG USE BG BOUNDRY FOR SEGMENTED PROGS STA MHI SAVE HIGHEST MAIN ADDRESS LDA $BGBP USE BG BP BOUNDRY FOR SEGMENTED STA BHI SAVE HIGHEST BASE PAGE ADDRESS * CKBND LDA NULO CHECK NEW LOW BOUND JSB BCHEK CHECK BOUNDS DEF MLO DEF MHI STA BNDCK SAVE CONFLICT VALUE STB AB.BL SAVE ABOVE/BELOW INDICATOR LDA NUHI CHECK NEW HIGH BOUND JSB BCHEK DEF MLO DEF MHI ADA BNDCK ADD PREVIOUS CHECK SZA LOW AND HIGH BOUNDS OK? JMP ERBND NO, ERROR * ADB AB.BL YES, NOW TEST IF BOTH BOUNDS ON SAME SIDE SZB,RSS OF THIS PROGRAM JMP ERBND NO, SPANS THIS PROGRAM, ERROR. * LDA NULOB NOW CHECK LOW BP BOUND JSB BCHEK DEF BLO DEF BHI STA BNDCK SAVE CONFLICT VALUE STB AB.BL SAVE ABOVE/BELOW INDICATOR LDA NUHIB NOW CHECK HIGH BP BOUND JSB BCHEK DEF BLO DEF BHI ADA BNDCK ADD PREVIOUS CHECK SZA LOW AND HIGH BP BOUNDS OK? JMP ERBND NO, RETURN * ADB AB.BL YES, NOW TEST IF BOTH BOUNDS ON SAME SIDE SZB,RSS OF THIS PROGRAM JMP ERBND NO, NEW PROGRAM SPANS THIS ONE, ERROR * NEXT LDA IDPTR GET ID POINTER ADA $IDSZ AND INCREMENT TO NEXT ONE STA IDPTR SAVE FOR NEXT ROUND ISZ COUNT INCREMENT COUNT JMP LOOP DO IT AGAIN XIF SKP * * EXIT * EXIT CLA DONE, NO CONFLICTS JMP IDMEM,I EXIT * IFN *** L/10 CODE *** ERBND LDA IDPTR ERROR IN BOUNDS. RETURN POINTER JMP IDMEM,I TO NAME AND EXIT XIF SKP * * BCHEK: TESTS WHETHER THE A REGISTER IS GREATER THAN * OR EQUAL TO THE FIRST PARAMETER AND LESS THAN * THE SECOND PARAMETER. * * CALLING SEQUENCE: * * * JSB BCHEK * DEF LO BOUND * DEF HI BOUND * * +1 IF ABOVE UPPER BOUNDRY * IFN *** L/10 CODE *** BCHEK NOP * LDB BCHEK,I GET ADDRESS OF LOW BOUND STB LO STORE IN LOW ISZ BCHEK POINT TO UPPER BOUND LDB BCHEK,I GET ADDRESS OF HIGH BOUND STB HI ISZ BCHEK POINT TO RETURN ADDRESS * LDB LO,I GET LOW BOUND CMB,INB AND SET IT NEGATIVE ADB A ADD IN THE TEST BOUND SSB IS IT BELOW OR EQUAL OR ABOVE? JMP BELOW BELOW, ITS OK * LDB HI,I EQUAL OR ABOVE SO GET HIGH BOUND CMB,INB AND SET IT NEGATIVE ADB A ADD IN THE TEST BOUND SSB,RSS IS IT BELOW OR EQUAL OR ABOVE? JMP ABOVE EQUAL OR ABOVE, IT'S OK * CCA BELOW, IT'S IN THE RANGE CONFLICT JMP BCHEK,I RETURN * ABOVE CLB,INB OKEX CLA OK EXIT JMP BCHEK,I * BELOW CCB JMP OKEX XIF SKP * * STORAGE AREA * IFN *** L/10 CODE *** N1 DEC -1 * .2 DEC 2 .3 DEC 3 .8 DEC 8 .9 DEC 9 .12 DEC 12 .20 DEC 20 * B77 OCT 77 B1777 OCT 1777 * NULO NOP NEW LOW BOUND NUHI NOP NEW HIGH BOUND NULOB NOP NEW BASE PAGE LOW BOUND NUHIB NOP NEW BASE PAGE HIGH BOUND MLO NOP MAIN LOW MHI NOP MAIN HIGH BLO NOP BASE LOW BHI NOP BASE HIGH * COUNT NOP LOOP COUNTER IDPTR NOP POINTER TO NAME IN ID SEGMENT NUMSG NOP NUMBER OF SEGMENTS BNDCK NOP STORE RESULT OF BCHEK AB.BL NOP STORE ABOVE/BELOW RESULT OF BCHEK * LO NOP LOW BOUNDRY FOR BCHEK HI NOP HIGH BOUNDARY FOR BCHEK * FWBG NOP NEGATIVE VALUE OF FIRST WORD OF BACKGROUND XIF * A EQU 0 B EQU 1 * END EQU * * END