LDS, LES, LFS, LGS, LSS

Carga Far Pointer

estableVMJITAOTinstruccion

Codificaciones

Opcode	Instruccion	Op/En	64 bits	Compat/Legacy	Descripcion
`C5 /r`	`LDS r16,m16:16`	RM	No valido	Valido	Carga DS:r16 con mucho puntero de la memoria.
`C5 /r`	`LDS r32,m16:32`	RM	No valido	Valido	Carga DS:r32 con mucho puntero de la memoria.
`0F B2 /r`	`LSS r16,m16:16`	RM	Valido	Valido	Carga SS:r16 con mucho puntero de la memoria.
`0F B2 /r`	`LSS r32,m16:32`	RM	Valido	Valido	Carga SS:r32 con mucho puntero de la memoria.
`REX.W + 0F B2 /r`	`LSS r64,m16:64`	RM	Valido	No codificable	Carga SS:r64 con mucho puntero de la memoria.
`C4 /r`	`LES r16,m16:16`	RM	No valido	Valido	Carga ES:r16 con mucho puntero de la memoria.
`C4 /r`	`LES r32,m16:32`	RM	No valido	Valido	Carga ES:r32 con mucho puntero de la memoria.
`0F B4 /r`	`LFS r16,m16:16`	RM	Valido	Valido	Carga FS:r16 con mucho puntero de la memoria.
`0F B4 /r`	`LFS r32,m16:32`	RM	Valido	Valido	Carga FS:r32 con mucho puntero de la memoria.
`REX.W + 0F B4 /r`	`LFS r64,m16:64`	RM	Valido	No codificable	Carga FS:r64 con mucho puntero de la memoria.
`0F B5 /r`	`LGS r16,m16:16`	RM	Valido	Valido	Carga GS:r16 con mucho puntero de la memoria.
`0F B5 /r`	`LGS r32,m16:32`	RM	Valido	Valido	Carga GS:r32 con mucho puntero de la memoria.
`REX.W + 0F B5 /r`	`LGS r64,m16:64`	RM	Valido	No codificable	Carga GS:r64 con mucho puntero de la memoria.

Codificacion de operandos

Cada modo es un valor de la columna Op/En de arriba. Dice en que campo de la instruccion codificada va cada operando, en el orden en que se escriben, y si la instruccion lo lee, lo escribe o ambas cosas.

RM

modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

Coste medido

Cargando las mediciones de arch-data...

Descripción

Carga un puntero lejano (selector de segmento y offset) del segundo operando (operando de origen) en un registro de segmentos y el primer operando (operando de destino). El operando de origen especifica un puntero de 48 bits o de 32 bits en memoria dependiendo del ajuste actual del atributo de tamaño el operando (32 bits o 16 bits, respectivamente). La instrucción código de operación y el operando de destino especifican un registro de segmento/registro de proposito general par. El selector de segmento de 16 bits del operando de origen se carga en el registro de segmento especificado con el código de operación (DS, SS, ES, FS, o GS). El offset de 32 bits o 16 bits se carga en el registro especificado con el operando de destino.

Si una de estas instrucciones se ejecuta en modo protegido, la información adicional del descriptor de segmento apuntado por el selector de segmento en el operando de origen se carga en la parte oculta del registro de segmento seleccionado.

También en modo protegido, un selector NULL (valores 0000 a 0003) se puede cargar en registros DS, ES, FS o GS sin causar una excepción de protección. (Cualquier referencia posterior a un segmento cuyo registro de segmento correspondiente está cargado con un selector NULL, causa una excepción de protección general (#GP) y no se produce ninguna referencia de memoria al segmento).

En modo de 64 bits, el tamaño de operación predeterminado de la instrucción es de 32 bits. Utilizando un prefijo REX en forma de REX.W promueve la operación para especificar la referencia un operando de origen de un puntero de 80 bits (16-bit selector, 64-bit offset) en memoria. El uso de un prefijo REX en forma de REX.R permite el acceso a registros adicionales (R8-R15). Vea la tabla resumen al comienzo de esta sección para la codificación de datos y límites.

Operación

64-BIT_MODE
    IF SS is loaded
          THEN

             IF SegmentSelector = NULL and ( (RPL = 3) or
                       (RPL  3 and RPL  CPL) )

                      THEN #GP(0);
                ELSE IF descriptor is in non-canonical space


                       THEN #GP(selector); FI;
                ELSE IF Segment selector index is not within descriptor table limits

                       or segment selector RPL  CPL

                             or access rights indicate nonwritable data segment

                       or DPL  CPL

                       THEN #GP(selector); FI;
                ELSE IF Segment marked not present

                       THEN #SS(selector); FI;
                FI;
                SS := SegmentSelector(SRC);
                SS := SegmentDescriptor([SRC]);
    ELSE IF attempt to load DS, or ES
          THEN #UD;
    ELSE IF FS, or GS is loaded with non-NULL segment selector
          THEN IF Segment selector index is not within descriptor table limits
                or access rights indicate segment neither data nor readable code segment
                or segment is data or nonconforming-code segment
                and ( RPL > DPL or CPL > DPL)

                       THEN #GP(selector); FI;
                ELSE IF Segment marked not present

                       THEN #NP(selector); FI;
                FI;
                SegmentRegister := SegmentSelector(SRC) ;
                SegmentRegister := SegmentDescriptor([SRC]);
          FI;
    ELSE IF FS, or GS is loaded with a NULL selector:
          THEN
                SegmentRegister := NULLSelector;
                SegmentRegister(DescriptorValidBit) := 0; FI; (* Hidden flag;

                       not accessible by software *)
    FI;
    DEST := Offset(SRC);

PREOTECTED MODE OR COMPATIBILITY MODE;
    IF SS is loaded
          THEN

             IF SegementSelector = NULL

                       THEN #GP(0);
                ELSE IF Segment selector index is not within descriptor table limits

                       or segment selector RPL  CPL

                             or access rights indicate nonwritable data segment

                       or DPL  CPL

                       THEN #GP(selector); FI;
                ELSE IF Segment marked not present

                       THEN #SS(selector); FI;
                FI;
                SS := SegmentSelector(SRC);
                SS := SegmentDescriptor([SRC]);
    ELSE IF DS, ES, FS, or GS is loaded with non-NULL segment selector
          THEN IF Segment selector index is not within descriptor table limits
                or access rights indicate segment neither data nor readable code segment
                or segment is data or nonconforming-code segment
                and (RPL > DPL or CPL > DPL)

                       THEN #GP(selector); FI;
                ELSE IF Segment marked not present


                      THEN #NP(selector); FI;
                FI;
                SegmentRegister := SegmentSelector(SRC) AND RPL;
                SegmentRegister := SegmentDescriptor([SRC]);
          FI;
    ELSE IF DS, ES, FS, or GS is loaded with a NULL selector:
          THEN
                SegmentRegister := NULLSelector;
                SegmentRegister(DescriptorValidBit) := 0; FI; (* Hidden flag;

                      not accessible by software *)
    FI;
    DEST := Offset(SRC);

Real-Address or Virtual-8086 Mode
    SegmentRegister := SegmentSelector(SRC); FI;
    DEST := Offset(SRC);

Banderas afectadas

None.

Excepciones

Modo protegido

`#UD`	Si operando de origen no es una ubicación de memoria. Si el prefijo LOCK es usado.
`#GP(0)`	Si un selector NULL se carga en el registro SS. Si la dirección efectiva un operando de memoria está fuera del límite de segmento CS, DS, ES, FS o GS. Si el registro DS, ES, FS o GS se utiliza para acceder a la memoria y contiene un NULL selector de segmento.
`#GP(selector)`	Si el registro SS está siendo cargado y cualquiera de los siguientes es cierto:el selector de segmentoel índice no está dentro de los límites de la tabla descriptor,el selector de segmento RPLno es igual aCPL, el segmento es un segmento de datos no escrito, oDPLno es igual aCPL. Si el registro DS, ES, FS o GS está siendo cargado con un no-NULL selector de segmentoy cualquiera de los siguientes es cierto:el selector de segmentoel índice no está dentro de los límites de tabla descriptor, el segmento no es ni un segmento de código legible, o el segmento es un segmento de datos o código no conforme y ambosRPLyCPLson mayores queDPL.
`#SS(0)`	Si un operando de memoria dirección efectiva está fuera del límite del segmento SS.
`#SS(selector)`	Si el registro SS está siendo cargado y el segmento no está marcado.
`#NP(selector)`	Si el registro DS, ES, FS o GS está siendo cargado con un no NULL selector de segmento y el segmento no está marcado. #PF(fault-code) Si un fallo de pagina ocurre.
`#AC(0)`	Si la comprobación de alineación está habilitada y se hace una referencia de memoria no alineada mientras que el nivel de privilegio actual es 3.

Modo real

`#GP`	Si un operando de memoria dirección efectiva está fuera del límite de segmento CS, DS, ES, FS o GS.
`#SS`	Si un operando de memoria dirección efectiva está fuera del límite del segmento SS.
`#UD`	Si operando de origen no es una ubicación de memoria. Si el prefijo LOCK es usado.

Modo virtual-8086

`#UD`	Si operando de origen no es una ubicación de memoria. Si el prefijo LOCK es usado.
`#GP(0)`	Si un operando de memoria dirección efectiva está fuera del límite de segmento CS, DS, ES, FS o GS.
`#SS(0)`	Si un operando de memoria dirección efectiva está fuera del límite del segmento SS. #PF(fault-code) Si un fallo de pagina ocurre.
`#AC(0)`	Si la comprobación de alineación está habilitada y se hace una referencia de memoria no alineada.

Modo de compatibilidad

Las mismas excepciones que en modo protegido.

Modo de 64 bits

`#GP(0)`	Si la dirección de memoria está en forma no canónica.NULLselector se intenta cargar en el registro SS en modo de compatibilidad.NULLselector se intenta cargar en el registro SS enCPL3y modo 64-bit.NULLselector se intenta cargar en el registro SS en no-CPL3y modo 64-bit donde suRPLno es igual aCPL.
`#GP(Selector)`	Si el registro de FS o GS está siendo cargado con un no-NULL selector de segmentoy cualquiera de los siguientes es cierto:el selector de segmentoel índice no está dentro de los límites de la tabla descriptor, la dirección de memoria del descriptor no es canónica, el segmento no es ni un segmento de código legible, o el segmento es un segmento de datos o código no conforme y ambosRPLyCPLson mayores queDPL. Si el registro SS está siendo cargado y cualquiera de los siguientes es cierto:el selector de segmentoel índice no está dentro de los límites de la tabla descriptor, la dirección de memoria del descriptor es no canónico,el selector de segmento RPLno es igual aCPL, el segmento es un segmento de datos no escrito, oDPLno es igual aCPL.
`#SS(0)`	Si un operando de memoria dirección efectiva no es canónica
`#SS(Selector)`	Si el registro SS está siendo cargado y el segmento no está marcado.
`#NP(selector)`	Si el registro de FS, o GS está siendo cargado con un NULL selector de segmento y el segmento no está marcado. #PF(fault-code) Si un fallo de pagina ocurre.
`#AC(0)`	Si la comprobación de alineación está habilitada y se hace una referencia de memoria no alineada mientras que el nivel de privilegio actual es 3.
`#UD`	Si operando de origen no es una ubicación de memoria. Si el prefijo LOCK es usado.

LDS, LES, LFS, LGS, LSS

Codificaciones

Codificacion de operandos

RM

Coste medido

Descripción#

Operación#

Banderas afectadas#

Excepciones

Fuentes

Descripción

Operación

Banderas afectadas