invpcid

Invalidate Process-Context Identifier

INVPCID r32, m128

Invalidates TLB entries based on PCID.

Details

Invalidates TLB entries based on the PCID (Process-Context Identifier) specified in the 128-bit memory operand, with the invalidation type determined by the descriptor type field. The source register provides an address (typically a general register holding PCID context information), and the memory operand contains the full 128-bit invalidation descriptor. This is a privileged instruction (CPL 0 only) that serializes the pipeline and requires the INVPCID extension. No flags are affected.

Pseudocode Operation

descriptor ← [src + 0:127];
invalidation_type ← descriptor.type;
pcid ← descriptor.pcid;
switch(invalidation_type) {
  case 0: invalidate_tlb_entry_by_pcid(pcid); break;
  case 1: invalidate_all_tlb_entries_by_pcid(pcid); break;
  case 2: invalidate_all_tlb_entries(); break;
  case 3: invalidate_all_tlb_entries_except_global(); break;
}
pipeline_serialization();

Example

INVPCID eax, [rbp-16]

Encoding

Binary Layout
66
+0
0F
+1
38
+2
82
+3
 
Format Legacy
Opcode 66 0F 38 82
Extension INVPCID

Operands

  • dest
    32-bit general-purpose register (e.g. EAX)
  • src
    128-bit memory operand

Reference (Intel® SDM)

Instruction Forms

Opcode Instruction Op/En 64/32-bit Mode CPUID Description
66 0F 38 82 /r INVPCID RM N.E./V Invalidates entries in the TLBs and paging-structure INVPCID r32, m128 caches based on invalidation type in r32 and descriptor in m128.
66 0F 38 82 /r INVPCID RM V/N.E. Invalidates entries in the TLBs and paging-structure INVPCID r64, m128 caches based on invalidation type in r64 and descriptor in m128.

Description

Invalidates mappings in the translation lookaside buffers (TLBs) and paging-structure caches based on processcontext identifier (PCID). (See Section 5.10, “Caching Translation Information,” in the Intel 64 and IA-32 Architecture Software Developer’s Manual, Volume 3A.) Invalidation is based on the INVPCID type specified in the register operand and the INVPCID descriptor specified in the memory operand. Outside 64-bit mode, the register operand is always 32 bits, regardless of the value of CS.D. In 64-bit mode the register operand has 64 bits. There are four INVPCID types currently defined: • Individual-address invalidation: If the INVPCID type is 0, the logical processor invalidates mappings—except global translations—for the linear address and PCID specified in the INVPCID descriptor.1 In some cases, the instruction may invalidate global translations or mappings for other linear addresses (or other PCIDs) as well. • Single-context invalidation: If the INVPCID type is 1, the logical processor invalidates all mappings—except global translations—associated with the PCID specified in the INVPCID descriptor. In some cases, the instruction may invalidate global translations or mappings for other PCIDs as well. • All-context invalidation, including global translations: If the INVPCID type is 2, the logical processor invalidates all mappings—including global translations—associated with any PCID. • All-context invalidation: If the INVPCID type is 3, the logical processor invalidates all mappings—except global translations—associated with any PCID. In some case, the instruction may invalidate global translations as well. The INVPCID descriptor comprises 128 bits and consists of a PCID and a linear address as shown in Figure 3-20. For INVPCID type 0, the processor uses the full 64 bits of the linear address even outside 64-bit mode; the linear address is not used for other INVPCID types. 127 64 63 12 11 0 Linear Address Reserved (must be zero) PCID Figure 3-20. INVPCID Descriptor 1. If the paging structures map the linear address using a page larger than 4 KBytes and there are multiple TLB entries for that page (see Section 5.10.2.3, “Details of TLB Use,” in the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A), the instruction invalidates all of them. INVPCID—Invalidate Process-Context Identifier Vol. 2A 3-487 If CR4.PCIDE = 0, a logical processor does not cache information for any PCID other than 000H. In this case, executions with INVPCID types 0 and 1 are allowed only if the PCID specified in the INVPCID descriptor is 000H; executions with INVPCID types 2 and 3 invalidate mappings only for PCID 000H. Note that CR4.PCIDE must be 0 outside IA-32e mode (see Section 5.10.1, “Process-Context Identifiers (PCIDs),” of the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A).

Operation

INVPCID_TYPE := value of register operand;         // must be in the range of 0–3
INVPCID_DESC := value of memory operand;
CASE INVPCID_TYPE OF
0:                     // individual-address invalidation
PCID := INVPCID_DESC[11:0];
L_ADDR := INVPCID_DESC[127:64];
Invalidate mappings for L_ADDR associated with PCID except global translations;
BREAK;
1:                     // single PCID invalidation
PCID := INVPCID_DESC[11:0];
Invalidate all mappings associated with PCID except global translations;
BREAK;
2:                     // all PCID invalidation including global translations
Invalidate all mappings for all PCIDs, including global translations;
BREAK;
3:                     // all PCID invalidation retaining global translations
Invalidate all mappings for all PCIDs except global translations;
BREAK;
ESAC;

Intel C/C++ Compiler Intrinsic Equivalent

INVPCID void _invpcid(unsigned __int32 type, void * descriptor);

Exceptions

SIMD Floating-Point Exceptions

None.

Protected Mode Exceptions

#GP(0) If the current privilege level is not 0. If the memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register contains an unusable segment. If the source operand is located in an execute-only code segment. If an invalid type is specified in the register operand, i.e., INVPCID_TYPE > 3. If bits 63:12 of INVPCID_DESC are not all zero. If INVPCID_TYPE is either 0 or 1 and INVPCID_DESC[11:0] is not zero. If INVPCID_TYPE is 0 and the linear address in INVPCID_DESC[127:64] is not canonical. #PF(fault-code) If a page fault occurs in accessing the memory operand. #SS(0) If the memory operand effective address is outside the SS segment limit. If the SS register contains an unusable segment. #UDIf if CPUID.07H.00H:EBX.INVPCID[10] = 0. If the LOCK prefix is used. INVPCID—Invalidate Process-Context Identifier Vol. 2A 3-488

Real-Address Mode Exceptions

#GP If an invalid type is specified in the register operand, i.e., INVPCID_TYPE > 3. If bits 63:12 of INVPCID_DESC are not all zero. If INVPCID_TYPE is either 0 or 1 and INVPCID_DESC[11:0] is not zero. If INVPCID_TYPE is 0 and the linear address in INVPCID_DESC[127:64] is not canonical. #UD If CPUID.07H.00H:EBX.INVPCID[10] = 0. If the LOCK prefix is used.

Virtual-8086 Mode Exceptions

#GP(0) The INVPCID instruction is not recognized in virtual-8086 mode.

Compatibility Mode Exceptions

Same exceptions as in protected mode.

64-Bit Mode Exceptions

#GP(0) If the current privilege level is not 0. If the memory operand is in the CS, DS, ES, FS, or GS segments and the memory address is in a non-canonical form. If an invalid type is specified in the register operand, i.e., INVPCID_TYPE > 3. If bits 63:12 of INVPCID_DESC are not all zero. If CR4.PCIDE=0, INVPCID_TYPE is either 0 or 1, and INVPCID_DESC[11:0] is not zero. If INVPCID_TYPE is 0 and the linear address in INVPCID_DESC[127:64] is not canonical. #PF(fault-code) If a page fault occurs in accessing the memory operand. #SS(0) If the memory destination operand is in the SS segment and the memory address is in a non- canonical form. #UD If the LOCK prefix is used. If CPUID.07H.00H:EBX.INVPCID[10] = 0. INVPCID—Invalidate Process-Context Identifier Vol. 2A 3-489