United States

Compaq C

# Compaq C
User's Guide for OpenVMS Systems

Previous | Contents | Index

### 6.2.1.59 __PAL_INSQTILR

This function inserts an entry at the end of a longword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries. The pointers to head and new_entry must not be equal. All parts of the queue must be memory resident.

This function has the following format:

`int __PAL_INSQTILR (void *head, void *new_entry); /* At tail, interlocked resident */`

> ### head

> A pointer to the queue header. The header must be aligned on a quadword boundary.

> ### new_entry

> A pointer to the new entry to be inserted. The entry must be aligned on a quadword boundary.

There are three possible return values:

- --1 if the entry was not inserted because the secondary interlock failed
- 0 if the entry was inserted but it was not the only entry in the list
- 1 if the entry was inserted and it was the only entry in the list

### 6.2.1.60 __PAL_INSQTIQ

This function inserts an entry at the end of a quadword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to header and queue entries. The pointers to head and new_entry must not be equal.

This function has the following format:

`int __PAL_INSQTIQ (void *head, void *new_entry); /* At tail, interlocked */`

> ### head

> A pointer to the queue header. The header must be aligned on an octaword boundary.

> ### new_entry

> A pointer to the new entry to be inserted. The entry must be aligned on an octaword boundary.

There are three possible return values:

- --1 if the entry was not inserted because the secondary interlock failed
- 0 if the entry was inserted but it was not the only entry in the list
- 1 if the entry was inserted and it was the only entry in the list

### 6.2.1.61 __PAL_INSQTIQR

This function inserts an entry at the end of a quadword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries. The pointers to head and new_entry must not be equal. All parts of the queue must be memory resident.

This function has the following format:

`int __PAL_INSQTIQR (void *head, void *new_entry); /* At tail, interlocked resident */`

> ### head

> A pointer to the queue header. The header must be aligned on an octaword boundary.

> ### new_entry

> A pointer to the new entry to be inserted. The entry must be aligned on an octaword boundary.

There are three possible return values:

- --1 if the entry was not inserted because the secondary interlock failed
- 0 if the entry was inserted but it was not the only entry in the list
- 1 if the entry was inserted and it was the only entry in the list

### 6.2.1.62 __PAL_INSQUEL

This function inserts a new entry after an existing entry into a longword queue. This function must have write access to header and queue entries.

This function has the following format:

`int __PAL_INSQUEL (void *predecessor, void *new_entry);`

> ### predecessor

> A pointer to an existing entry in the queue.

> ### new_entry

> A pointer to the new entry to be inserted.

There are two possible return values:

- 0 if the entry was not the only entry in the queue
- 1 if the entry was the only entry in the queue

### 6.2.1.63 __PAL_INSQUEL_D

This function inserts a new entry after an existing entry into a longword queue deferred. This function must have write access to header and queue entries.

This function has the following format:

`int __PAL_INSQUEL_D (void **predecessor, void *new_entry); /* Deferred */`

> ### predecessor

> A pointer to a pointer to the predecessor entry.

> ### new_entry

> A pointer to the new entry to be inserted.

There are two possible return values:

- 0 if the entry was not the only entry in the queue
- 1 if the entry was the only entry in the queue

### 6.2.1.64 __PAL_INSQUEQ

This function inserts a new entry after an existing entry into a quadword queue. The entries must be octaword-aligned. This function must have write access to header and queue entries.

This function has the following format:

`int __PAL_INSQUEQ (void *predecessor, void *new_entry);`

> ### predecessor

> A pointer to an existing entry in the queue.

> ### new_entry

> A pointer to the new entry to be inserted.

There are two possible return values:

- 0 if the entry was not the only entry in the queue
- 1 if the entry was the only entry in the queue

### 6.2.1.65 __PAL_INSQUEQ_D

This function inserts a new entry after an existing entry into a quadword queue deferred. The entries must be octaword-aligned. This function must have write access to header and queue entries.

This function has the following format:

`int __PAL_INSQUEQ_D (void **predecessor, void *new_entry); /* Deferred */`

> ### predecessor

> A pointer to a pointer to the predecessor entry.

> ### new_entry

> A pointer to the new entry to be inserted.

There are two possible return values:

- 0 if the entry was not the only entry in the queue
- 1 if the entry was the only entry in the queue

### 6.2.1.66 __PAL_LDQP

This function returns the quadword-aligned memory object specified by address.

This function has the following format:

`uint64 __PAL_LDQP (void *address);`

> ### address

> A pointer to the quadword-aligned memory object to be returned.

If the object pointed to by address is not quadword-aligned, the result is unpredictable.

### 6.2.1.67 __PAL_STQP

This function writes the quadword value to the memory location pointed to by address.

This function has the following format:

`void __PAL_STQP (void *address, uint64 value);`

> ### address

> Memory location to be written to.

> ### value

> Quadword value to be stored.

If the location pointed to by address is not quadword-aligned, the result is unpredictable.

### 6.2.1.68 __PAL_MFPR_XXXX

These privileged functions return the contents of a particular processor register. The XXXX indicates the processor register to be read.

These functions have the following format:

`unsigned int __PAL_MFPR_ASTEN (void); /* AST Enable */ unsigned int __PAL_MFPR_ASTSR (void); /* AST Summary Register */ void *__PAL_MFPR_ESP (void); /* Executive Stack Pointer */ int __PAL_MFPR_FEN (void); /* Floating-Point Enable */ int __PAL_MFPR_IPL (void); /* Interrupt Priority Level */ int __PAL_MFPR_MCES (void); /* Machine Check Error Summary */ void *__PAL_MFPR_PCBB (void); /* Privileged Context Block Base */ int64 __PAL_MFPR_PRBR (void); /* Processor Base Register */ int __PAL_MFPR_PTBR (void); /* Page Table Base Register */ void *__PAL_MFPR_SCBB (void); /* System Control Block Base */ unsigned int __PAL_MFPR_SISR (void); /* Software Interrupt Summary Register */ void *__PAL_MFPR_SSP (void); /* Supervisor Stack Pointer */ int64 __PAL_MFPR_TBCHK (void *address); /* Translation Buffer Check */ void *__PAL_MFPR_USP (void); /* User Stack Pointer */ void *__PAL_MFPR_VPTB (void); /* Virtual Page Table */ int64 __PAL_MFPR_WHAMI (void); /* Who Am I */`

### 6.2.1.69 __PAL_MTPR_XXXX

These privileged functions load a value into one of the special processor registers. The XXXX indicates the processor register to be loaded.

These functions have the following format:

`void __PAL_MTPR_ASTEN (unsigned int mask); /* AST Enable */ void __PAL_MTPR_ASTSR (unsigned int mask); /* AST Summary Register */ void __PAL_MTPR_DATFX (int value); /* Data Alignment Trap Fixup */ void __PAL_MTPR_ESP (void *address); /* Executive Stack Pointer */ void __PAL_MTPR_FEN (int value); /* Floating-Point Enable */ void __PAL_MTPR_IPIR (int64 number); /* Interprocessor Interrupt Request */ int __PAL_MTPR_IPL (int value); /* Interrupt Priority Level */ void __PAL_MTPR_MCES (int value); /* Machine Check Error Summary */ void __PAL_MTPR_PRBR (int64 value); /* Processor Base Register */ void __PAL_MTPR_SCBB (void *address); /* System Control Block Base */ void __PAL_MTPR_SIRR (int level); /* Software Interrupt Request Register */ void __PAL_MTPR_SSP (int *address); /* Supervisor Stack Pointer */ void __PAL_MTPR_TBIA (void); /* User Stack Pointer */ void __PAL_MTPR_TBIAP (void); /* Translation Buffer Invalidate All Process */ void __PAL_MTPR_TBIS (void *address); /* Translation Buffer Invalidate Single */ void __PAL_MTPR_TBISD (void *address); /* Translation Buffer Invalidate Single Data */ void __PAL_MTPR_TBISI (void *address); /* Translation Buffer Invalidate Single Instruction */ void __PAL_MTPR_USP (void *address); /* User Stack Pointer */ void __PAL_MTPR_VPTB (void *address); /* Virtual Page Table */`

### 6.2.1.70 __PAL_PROBER

This function checks the read accessibility of the first and last byte of the given address and offset pair.

This function has the following format:

`int __PAL_PROBER (const void *base_address, int offset, char mode);`

> ### base_address

> The pointer to the memory segment to be tested for read access.

> ### offset

> The signed offset to the last byte in the memory segment.

> ### mode

> The processor mode used for checking access.

There are two possible return values:

- 0 if one or both bytes are not accessible
- 1 if both bytes are accessible

### 6.2.1.71 __PAL_PROBEW

This function checks the write accessibility of the first and last byte of the given address and offset pair.

This function has the following format:

`int __PAL_PROBEW (const void *base_address, int offset, char mode);`

> ### base_address

> The pointer to the memory segment to be tested for write access.

> ### offset

> The signed offset to the last byte in the memory segment.

> ### mode

> The processor mode used for checking access.

There are two possible return values:

- 0 if one or both bytes are not accessible
- 1 if both bytes are accessible

### 6.2.1.72 __PAL_RD_PS

This function returns the Processor Status (PS).

This function has the following format:

`uint64 __PAL_RD_PS (void);`

### 6.2.1.73 __PAL_REMQHIL

This function removes the first entry from a longword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries.

This function has the following format:

`int __PAL_REMQHIL (void *head, void **removed_entry); /* At head, interlocked */`

> ### head

> A pointer to the queue header. The header must be aligned on a quadword boundary.

> ### removed_entry

> A pointer to the address of the entry removed from the queue.

There are four possible return values:

- --1 if the entry cannot be removed because the secondary interlock failed
- 0 if the queue was empty
- 1 if the entry was removed and the queue has remaining entries
- 2 if the entry was removed and the queue is now empty

### 6.2.1.74 __PAL_REMQHILR

This function removes the first entry from a longword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries. All parts of the queue must be memory resident.

This function has the following format:

`int __PAL_REMQHILR (void *head, void **removed_entry); /* At head, interlocked resident */`

> ### head

> A pointer to the queue header. The header must be aligned on a quadword boundary.

> ### removed_entry

> A pointer to the address of the entry removed from the queue.

There are four possible return values:

- --1 if the entry cannot be removed because the secondary interlock failed
- 0 if the queue was empty
- 1 if the entry was removed and the queue has remaining entries
- 2 if the entry was removed and the queue is now empty

### 6.2.1.75 __PAL_REMQHIQ

This function removes the first entry from a quadword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries.

This function has the following format:

`int __PAL_REMQHIQ (void *head, void **removed_entry); /* At head, interlocked */`

> ### head

> A pointer to the queue header. The header must be aligned on an octaword boundary.

> ### removed_entry

> A pointer to the address of the entry removed from the queue.

There are four possible return values:

- --1 if the entry cannot be removed because the secondary interlock failed
- 0 if the queue was empty
- 1 if the entry was removed and the queue has remaining entries
- 2 if the entry was removed and the queue is now empty

### 6.2.1.76 __PAL_REMQHIQR

This function removes the first entry from a quadword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries. All parts of the queue must be memory resident.

This function has the following format:

`int __PAL_REMQHIQR (void *head, void **removed_entry); /* At head, interlocked resident */`

> ### head

> A pointer to the queue header. The header must be aligned on an octaword boundary.

> ### removed_entry

> A pointer to the address of the entry removed from the queue.

There are four possible return values:

- --1 if the entry cannot be removed because the secondary interlock failed
- 0 if the queue was empty
- 1 if the entry was removed and the queue has remaining entries
- 2 if the entry was removed and the queue is now empty

### 6.2.1.77 __PAL_REMQTIL

This function removes the last entry from a longword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries.

This function has the following format:

`int __PAL_REMQTIL (void *head, void **removed_entry); /* At tail, interlocked */`

> ### head

> A pointer to the queue header. The header must be aligned on a quadword boundary.

> ### removed_entry

> A pointer to the address of the entry removed from the queue.

There are four possible return values:

- --1 if the entry cannot be removed because the secondary interlock failed
- 0 if the queue was empty
- 1 if the entry was removed and the queue has remaining entries
- 2 if the entry was removed and the queue is now empty

### 6.2.1.78 __PAL_REMQTILR

This function removes the last entry from a longword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries. All parts of the queue must be memory resident.

This function has the following format:

`int __PAL_REMQTILR (void *head, void **removed_entry); /* At tail, interlocked resident */`

> ### head

> A pointer to the queue header. The header must be aligned on a quadword boundary.

> ### removed_entry

> A pointer to the address of the entry removed from the queue.

There are four possible return values:

- --1 if the entry cannot be removed because the secondary interlock failed
- 0 if the queue was empty
- 1 if the entry was removed and the queue has remaining entries
- 2 if the entry was removed and the queue is now empty

### 6.2.1.79 __PAL_REMQTIQ

This function removes the last entry from a quadword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries.

This function has the following format:

`int __PAL_REMQTIQ (void *head, void **removed_entry); /* At tail, interlocked */`

> ### head

> A pointer to the queue header. The header must be aligned on an octaword boundary.

> ### removed_entry

> A pointer to the address of the entry removed from the queue.

There are four possible return values:

- --1 if the entry cannot be removed because the secondary interlock failed
- 0 if the queue was empty
- 1 if the entry was removed and the queue has remaining entries
- 2 if the entry was removed and the queue is now empty

### 6.2.1.80 __PAL_REMQTIQR

This function removes the last entry from a quadword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries. All parts of the queue must be memory resident.

This function has the following format:

`int __PAL_REMQTIQR (void *head, void **removed_entry); /* At tail, interlocked resident */`

> ### head

> A pointer to the queue header. The header must be aligned on an octaword boundary.

> ### removed_entry

> A pointer to the address of the entry removed from the queue.

There are four possible return values:

- --1 if the entry cannot be removed because the secondary interlock failed
- 0 if the queue was empty
- 1 if the entry was removed and the queue has remaining entries
- 2 if the entry was removed and the queue is now empty

### 6.2.1.81 __PAL_REMQUEL

This function removes an entry from a longword queue. This function must have write access to header and queue entries.

This function has the following format:

`int _PAL_REMQUEL (void *entry, void **removed_entry);`

> ### entry

> A pointer to the queue entry to be removed.

> ### removed_entry

> A pointer to the address of the entry removed from the queue.

There are three possible return values:

- --1 if the queue was empty
- 0 if the entry was removed and the queue is now empty
- 1 if the entry was removed and the queue has remaining entries

Previous | Next | Contents | Index

privacy and legal statement