HP OpenVMS Systems Documentation

Upgrading Privileged-Code Applications on OpenVMS Alpha and OpenVMS I64 Systems

There are two major changes necessary to the OpenVMS infrastructure to accommodate 50-bit physical addressing. These changes are for privileged applications on the I64 platform only. Alpha code does not require any change.

• The Page Frame Number (PFN) field in the Page Table Entry (PTE) structure is a 40-bits field on I64 instead of a 32-bit field on Alpha.
• All other PFNs in structures, data cells, and routine interfaces are 64 bits on I64 instead of 32 bits on Alpha.

The following sections discuss how to change your code to accommodate these infrastructure differences. In most cases, you can change your I64 code so it is common code with Alpha.

To help you find which modules might require changing, we have created a command procedure that searches for all structure fields, data cells and routines mentioned in this document. Refer to Section 9 for more information.

7.1 C Programming

This section contains instructions for C programmers.

7.1.1 PTE Field References in C

The field PTE$V_PFN is defined in ptedef.h. This field is used to reference the PFN stored in a valid or transition PTE. The following are examples of good C programming:

    PTE local_pte;     local_pte.pte$v_pfn = pfn; 

    PTE_PQ va_pte;     pfn = va_pte->pte$v_pfn; 

These references work correctly as common code on Alpha and I64.

Some C code may assume that the PFN field is 32-bits at bit position 32. This is a bad example:

    unsigned __int64 pte;     pfn = pte >> 32;  

This code must be changed to use the PTE structure and the field pte$v_pfn as shown in the good programming examples above.

7.1.2 PFN References in C

PFNs are often stored as 32-bit integer variables in existing C code. These are sometimes signed and sometimes unsigned.

An example of an existing PFN:

    unsigned int new_pfn; 

A new type is defined in lib_types.h called PFN_T. This type is 32-bits on Alpha and 64-bits on I64.

When modifying your code for 64-bit PFNs, you can use unsigned __int64 or the PFN_T type. This is your choice.

New Code

    unsigned __int64 new_pfn; 

Alternate New Code

    #include <lib_types.h>     PFN_T new_pfn; 

When examining C code, look for casts of PFN fields and variables. Also look for assignment to and from other 32-bit ariables.

Example of Bad Code

    pfn = (int)foo; 

You can eliminate the need for a cast or change the cast to unsigned __int64 or PFN_T. This depends on the context of the code in question.

New Code

    pfn = (unsigned __int64)foo; 

Alternate New Code

    pfn = (PFN_T)foo; 

Using unsigned __int64 is sometimes preferable to PFN_T. This is because the PFN_T typedef includes conditionals for Alpha and IA64. In general, less conditional code is better because it insures that the same code is tested in both cases.

Example

    unsigned __int64 pfn;     unsigned __int64 pa;     int boff;     pfn = pte_contents.pte$v_pfn;     pa = (pfn << mmg$gl_bwp_width)| boff; 

Code that calculates a physical address from a PFN requires 64-bit arithmetic. The declaration of the pfn variable as unsigned __int64 insures this calculation is done correctly. In the above example, if the pfn variable were switched to type PFN_T, the line that computes the pa variable would execute differently on Alpha and I64 because the size of the pfn variable differs.

A good "rule of thumb" is this: if your code already uses unsigned __int64 as a PFN type, you should probably leave it alone.

7.2 Macro-32 Programming

The PTE$V_PFN field is used to reference the PFN stored in a valid or transition PTE. The symbols PTE$V_PFN, PTE$S_PFN and PTE$M_PFN are defined in $PTEDEF. This table shows the symbol values on Alpha and I64.

In Macro-32 PFNs can be shifted or extracted from PTEs. Also, PFNs can be shifted or inserted to PTEs.

Good Example 1

    ; R0 = PFN, R1 = PTE contents, R3 = PTE address     EVAX_SRL R1,#PTE$V_PFN,R0   ; Get PFN from PTE     EXTZV    R1,#PTE$V_PFN,#PTE$S_PFN,R0 

Good Example 2

    ; R0 = PFN, R1 = PTE contents, R3 = PTE address     EVAX_SLL R0,#PTE$V_PFN,R1   ; Put PFN into PTE position     INSV  R0,#PTE$V_PFN,#PTE$S_PFN,(R3) ; Store PFN into PTE 

These references work correctly as common code on Alpha and I64. Some Macro-32 code may assume that the PFN field is the upper longword of the PTE.

Bad Example

   ASSUME PTE$V_PFN EQ 32    MOVL R0,4(R3)    ; Store PFN into PTE 

This code must be changed to use the PTE structure symbols as shown above.

7.2.2 PFN References in Macro-32

PFNs are often treated as longwords in existing Macro-32 code. You must change your code to ensure that the high order 32-bits are not truncated or sign extended.

Existing Code

    TSTL R0             ; Is there a PFN?     BNEQ 10$            ; If neq, yes 

New Code

    EVAX_BNE R0,10$     ; Branch if we have a PFN 

Existing Code

    MOVL R0,R7          ; Copy PFN 

New Code

    EVAX_OR R0,R31,R7   ; Copy PFN 

Existing Code

    INCL R0             ; Next PFN 

New Code

    EVAX_ADDQ R0,#1,R0  ; Next PFN 

The above examples work correctly as common code on Alpha and I64. In other cases, you must conditionalize your code because the Alpha has 32-bit storage and I64 has 64-bit storage.

Existing Code

    MOVL     GSD$L_BASEPFN(R10),R0     ; Read the base PFN 

New Code

    .IF DF ALPHA     MOVL     GSD$I_BASEPFN(R10),R0     ; Read the base PFN     .ENDC      .IF DF IA64     EVAX_LDQ R0,GSD$I_BASEPFN(R10)     ; Read the base PFN     .ENDC 

Notice that the new Macro-32 code is awkward. This code could have been common between Alpha and I64 if it were written in C.

To help program conditional code referencing "I" fields in structures, several new macros have been added to lib.mlb.

The above example can be programmed with the LOAD$I macro as follows:

    LOAD$I  R0, GSD$I_BASEPFN(R10) ; Read the base PFN