Lines Matching +full:is +full:- +full:decoded +full:- +full:cs
14 #include <asm/insn-eval.h>
29 * is_string_insn() - Determine if instruction is a string instruction
34 * true if the instruction, determined by the opcode, is any of the
42 /* All string instructions have a 1-byte opcode. */ in is_string_insn()
43 if (insn->opcode.nbytes != 1) in is_string_insn()
46 switch (insn->opcode.bytes[0]) { in is_string_insn()
57 * insn_has_rep_prefix() - Determine if instruction has a REP prefix
80 * get_seg_reg_override_idx() - obtain segment register override index
87 * A constant identifying the segment register to use, among CS, SS, DS,
88 * ES, FS, or GS. INAT_SEG_REG_DEFAULT is returned if no segment override
91 * -EINVAL in case of error.
137 return -EINVAL; in get_seg_reg_override_idx()
143 * check_seg_overrides() - check if segment override prefixes are allowed
145 * @regoff: Operand offset, in pt_regs, for which the check is performed
147 * For a particular register used in register-indirect addressing, determine if
165 * resolve_default_seg() - resolve default segment register index for an operand
168 * @off: Operand offset, in pt_regs, for which resolution is needed
171 * operand register indicated by @off. Such index is resolved based on defaults
177 * among CS, SS, ES or DS. If in long mode, INAT_SEG_REG_IGNORE.
179 * -EINVAL in case of error.
191 * + AX, CX and DX are not valid register operands in 16-bit address in resolve_default_seg()
192 * encodings but are valid for 32-bit and 64-bit encodings. in resolve_default_seg()
193 * + -EDOM is reserved to identify for cases in which no register in resolve_default_seg()
194 * is used (i.e., displacement-only addressing). Use DS. in resolve_default_seg()
196 * + CS for rIP. in resolve_default_seg()
204 if (insn->addr_bytes == 2) in resolve_default_seg()
205 return -EINVAL; in resolve_default_seg()
209 case -EDOM: in resolve_default_seg()
227 return -EINVAL; in resolve_default_seg()
232 * resolve_seg_reg() - obtain segment register index
240 * The segment register associated to an operand used in register-indirect
252 * default segment register associated with the operand register is used.
262 * The operand register, @regoff, is represented as the offset from the base of
265 * As stated, the main use of this function is to determine the segment register
268 * @insn at all as in this case CS is used in all cases. This case is checked
278 * An index identifying the segment register to use, among CS, SS, DS,
279 * ES, FS, or GS. INAT_SEG_REG_IGNORE is returned if running in long mode.
281 * -EINVAL in case of error.
290 * be used. Hence, it is not necessary to inspect the instruction, in resolve_seg_reg()
301 return -EINVAL; in resolve_seg_reg()
327 * get_segment_selector() - obtain segment selector
331 * Obtain the segment selector from any of the CS, SS, DS, ES, FS, GS segment
332 * registers. In CONFIG_X86_32, the segment is obtained from either pt_regs or
333 * kernel_vm86_regs as applicable. In CONFIG_X86_64, CS and SS are obtained
343 * -EINVAL on error.
354 return (unsigned short)(regs->cs & 0xffff); in get_segment_selector()
356 return (unsigned short)(regs->ss & 0xffff); in get_segment_selector()
370 return -EINVAL; in get_segment_selector()
378 return (unsigned short)(regs->cs & 0xffff); in get_segment_selector()
380 return (unsigned short)(regs->ss & 0xffff); in get_segment_selector()
382 return vm86regs->ds; in get_segment_selector()
384 return vm86regs->es; in get_segment_selector()
386 return vm86regs->fs; in get_segment_selector()
388 return vm86regs->gs; in get_segment_selector()
391 return -EINVAL; in get_segment_selector()
397 return (unsigned short)(regs->cs & 0xffff); in get_segment_selector()
399 return (unsigned short)(regs->ss & 0xffff); in get_segment_selector()
401 return (unsigned short)(regs->ds & 0xffff); in get_segment_selector()
403 return (unsigned short)(regs->es & 0xffff); in get_segment_selector()
405 return (unsigned short)(regs->fs & 0xffff); in get_segment_selector()
414 return -EINVAL; in get_segment_selector()
446 * Don't possibly decode a 32-bit instructions as in get_reg_offset()
447 * reading a 64-bit-only register. in get_reg_offset()
449 if (IS_ENABLED(CONFIG_X86_64) && !insn->x86_64) in get_reg_offset()
450 nr_registers -= 8; in get_reg_offset()
454 regno = X86_MODRM_RM(insn->modrm.value); in get_reg_offset()
457 * ModRM.mod == 0 and ModRM.rm == 5 means a 32-bit displacement in get_reg_offset()
460 if (!X86_MODRM_MOD(insn->modrm.value) && regno == 5) in get_reg_offset()
461 return -EDOM; in get_reg_offset()
463 if (X86_REX_B(insn->rex_prefix.value)) in get_reg_offset()
468 regno = X86_MODRM_REG(insn->modrm.value); in get_reg_offset()
470 if (X86_REX_R(insn->rex_prefix.value)) in get_reg_offset()
475 regno = X86_SIB_INDEX(insn->sib.value); in get_reg_offset()
476 if (X86_REX_X(insn->rex_prefix.value)) in get_reg_offset()
481 * portion of the address computation is null. This is in get_reg_offset()
482 * true only if REX.X is 0. In such a case, the SIB index in get_reg_offset()
483 * is used in the address computation. in get_reg_offset()
485 if (X86_MODRM_MOD(insn->modrm.value) != 3 && regno == 4) in get_reg_offset()
486 return -EDOM; in get_reg_offset()
490 regno = X86_SIB_BASE(insn->sib.value); in get_reg_offset()
492 * If ModRM.mod is 0 and SIB.base == 5, the base of the in get_reg_offset()
493 * register-indirect addressing is 0. In this case, a in get_reg_offset()
494 * 32-bit displacement follows the SIB byte. in get_reg_offset()
496 if (!X86_MODRM_MOD(insn->modrm.value) && regno == 5) in get_reg_offset()
497 return -EDOM; in get_reg_offset()
499 if (X86_REX_B(insn->rex_prefix.value)) in get_reg_offset()
505 return -EINVAL; in get_reg_offset()
509 WARN_ONCE(1, "decoded an instruction with an invalid register"); in get_reg_offset()
510 return -EINVAL; in get_reg_offset()
516 * get_reg_offset_16() - Obtain offset of register indicated by instruction
523 * in @insn. This function is to be used with 16-bit address encodings. The
525 * indicated by the instruction. In cases where any of the registers is not
526 * referenced by the instruction, the value will be set to -EDOM.
530 * 0 on success, -EINVAL on error.
536 * 16-bit addressing can use one or two registers. Specifics of in get_reg_offset_16()
537 * encodings are given in Table 2-1. "16-Bit Addressing Forms with the in get_reg_offset_16()
556 -EDOM, in get_reg_offset_16()
557 -EDOM, in get_reg_offset_16()
558 -EDOM, in get_reg_offset_16()
559 -EDOM, in get_reg_offset_16()
563 return -EINVAL; in get_reg_offset_16()
565 /* Operand is a register, use the generic function. */ in get_reg_offset_16()
566 if (X86_MODRM_MOD(insn->modrm.value) == 3) { in get_reg_offset_16()
568 *offs2 = -EDOM; in get_reg_offset_16()
572 *offs1 = regoff1[X86_MODRM_RM(insn->modrm.value)]; in get_reg_offset_16()
573 *offs2 = regoff2[X86_MODRM_RM(insn->modrm.value)]; in get_reg_offset_16()
576 * If ModRM.mod is 0 and ModRM.rm is 110b, then we use displacement- in get_reg_offset_16()
579 * register offset is invalild. The second register offset is already in get_reg_offset_16()
582 if ((X86_MODRM_MOD(insn->modrm.value) == 0) && in get_reg_offset_16()
583 (X86_MODRM_RM(insn->modrm.value) == 6)) in get_reg_offset_16()
584 *offs1 = -EDOM; in get_reg_offset_16()
590 * get_desc() - Obtain contents of a segment descriptor
616 mutex_lock(¤t->active_mm->context.lock); in get_desc()
617 ldt = current->active_mm->context.ldt; in get_desc()
618 if (ldt && sel < ldt->nr_entries) { in get_desc()
619 *out = ldt->entries[sel]; in get_desc()
623 mutex_unlock(¤t->active_mm->context.lock); in get_desc()
631 * Segment descriptors have a size of 8 bytes. Thus, the index is in get_desc()
635 * All that remains is to clear bits [2:0]. in get_desc()
647 * insn_get_seg_base() - Obtain base address of segment descriptor.
652 * pointed by the segment selector. The segment selector is obtained from the
658 * except when FS or GS are used. In virtual-8086 mode, the segment
661 * -1L in case of error.
670 return -1L; in insn_get_seg_base()
674 * Base is simply the segment selector shifted 4 in insn_get_seg_base()
691 * MSR_KERNEL_GS_BASE will have the user-space GS base. in insn_get_seg_base()
705 return -1L; in insn_get_seg_base()
708 return -1L; in insn_get_seg_base()
714 * get_seg_limit() - Obtain the limit of a segment descriptor
719 * pointed by the segment selector. The segment selector is obtained from the
725 * In long mode and virtual-8086 mode, segment limits are not enforced. Thus,
726 * limit is returned as -1L to imply a limit-less segment.
728 * Zero is returned on error.
741 return -1L; in get_seg_limit()
750 * If the granularity bit is set, the limit is given in multiples in get_seg_limit()
763 * insn_get_code_seg_params() - Obtain code segment parameters
766 * Obtain address and operand sizes of the code segment. It is obtained from the
767 * selector contained in the CS register in regs. In protected mode, the default
768 * address is determined by inspecting the L and D bits of the segment
769 * descriptor. In virtual-8086 mode, the default is always two bytes for both
774 * An int containing ORed-in default parameters on success.
776 * -EINVAL on error.
784 /* Address and operand size are both 16-bit. */ in insn_get_code_seg_params()
792 return -EINVAL; in insn_get_code_seg_params()
796 * determines whether a segment contains data or code. If this is a data in insn_get_code_seg_params()
800 return -EINVAL; in insn_get_code_seg_params()
804 * Legacy mode. CS.L=0, CS.D=0. Address and operand size are in insn_get_code_seg_params()
805 * both 16-bit. in insn_get_code_seg_params()
809 * Legacy mode. CS.L=0, CS.D=1. Address and operand size are in insn_get_code_seg_params()
810 * both 32-bit. in insn_get_code_seg_params()
814 * IA-32e 64-bit mode. CS.L=1, CS.D=0. Address size is 64-bit; in insn_get_code_seg_params()
815 * operand size is 32-bit. in insn_get_code_seg_params()
818 case 3: /* Invalid setting. CS.L=1, CS.D=1 */ in insn_get_code_seg_params()
821 return -EINVAL; in insn_get_code_seg_params()
826 * insn_get_modrm_rm_off() - Obtain register in r/m part of the ModRM byte
833 * register is obtained as an offset from the base of pt_regs. In specific
834 * cases, the returned value can be -EDOM to indicate that the particular value
843 * insn_get_modrm_reg_off() - Obtain register in reg part of the ModRM byte
850 * register is obtained as an offset from the base of pt_regs.
858 * get_seg_base_limit() - obtain base address and limit of a segment
866 * @regoff and, if any or allowed, override prefixes in @insn. This function is
868 * associated with the instruction operand. If a limit is not needed (e.g.,
876 * -EINVAL on error.
885 return -EINVAL; in get_seg_base_limit()
892 if (*base == -1L) in get_seg_base_limit()
893 return -EINVAL; in get_seg_base_limit()
900 return -EINVAL; in get_seg_base_limit()
906 * get_eff_addr_reg() - Obtain effective address from register operand
913 * the ModRM byte. This function is to be used only with register addressing
914 * (i.e., ModRM.mod is 3). The effective address is saved in @eff_addr. The
915 * register operand, as an offset from the base of pt_regs, is saved in @regoff;
926 * -EINVAL on error.
937 if (X86_MODRM_MOD(insn->modrm.value) != 3) in get_eff_addr_reg()
938 return -EINVAL; in get_eff_addr_reg()
942 return -EINVAL; in get_eff_addr_reg()
945 if (insn->addr_bytes == 2) in get_eff_addr_reg()
947 else if (insn->addr_bytes == 4) in get_eff_addr_reg()
949 else /* 64-bit address */ in get_eff_addr_reg()
956 * get_eff_addr_modrm() - Obtain referenced effective address via ModRM
963 * identifying the registers involved in the register-indirect memory reference,
964 * its value is obtained from the operands in @regs. The computed address is
966 * segment is stored in @regoff, this parameter can later be used to determine
975 * -EINVAL on error.
983 if (insn->addr_bytes != 8 && insn->addr_bytes != 4) in get_eff_addr_modrm()
984 return -EINVAL; in get_eff_addr_modrm()
990 if (X86_MODRM_MOD(insn->modrm.value) > 2) in get_eff_addr_modrm()
991 return -EINVAL; in get_eff_addr_modrm()
996 * -EDOM means that we must ignore the address_offset. In such a case, in get_eff_addr_modrm()
997 * in 64-bit mode the effective address relative to the rIP of the in get_eff_addr_modrm()
1000 if (*regoff == -EDOM) { in get_eff_addr_modrm()
1002 tmp = regs->ip + insn->length; in get_eff_addr_modrm()
1006 return -EINVAL; in get_eff_addr_modrm()
1011 if (insn->addr_bytes == 4) { in get_eff_addr_modrm()
1012 int addr32 = (int)(tmp & 0xffffffff) + insn->displacement.value; in get_eff_addr_modrm()
1016 *eff_addr = tmp + insn->displacement.value; in get_eff_addr_modrm()
1023 * get_eff_addr_modrm_16() - Obtain referenced effective address via ModRM
1029 * Obtain the 16-bit effective address referenced by the ModRM byte of @insn.
1030 * After identifying the registers involved in the register-indirect memory
1031 * reference, its value is obtained from the operands in @regs. The computed
1032 * address is stored @eff_addr. Also, the register operand that indicates
1033 * the associated segment is stored in @regoff, this parameter can later be used
1042 * -EINVAL on error.
1050 if (insn->addr_bytes != 2) in get_eff_addr_modrm_16()
1051 return -EINVAL; in get_eff_addr_modrm_16()
1055 if (!insn->modrm.nbytes) in get_eff_addr_modrm_16()
1056 return -EINVAL; in get_eff_addr_modrm_16()
1058 if (X86_MODRM_MOD(insn->modrm.value) > 2) in get_eff_addr_modrm_16()
1059 return -EINVAL; in get_eff_addr_modrm_16()
1063 return -EINVAL; in get_eff_addr_modrm_16()
1070 if (addr_offset1 != -EDOM) in get_eff_addr_modrm_16()
1073 if (addr_offset2 != -EDOM) in get_eff_addr_modrm_16()
1076 displacement = insn->displacement.value & 0xffff; in get_eff_addr_modrm_16()
1091 * get_eff_addr_sib() - Obtain referenced effective address via SIB
1098 * identifying the registers involved in the indexed, register-indirect memory
1099 * reference, its value is obtained from the operands in @regs. The computed
1100 * address is stored @eff_addr. Also, the register operand that indicates the
1101 * associated segment is stored in @regoff, this parameter can later be used to
1119 if (insn->addr_bytes != 8 && insn->addr_bytes != 4) in get_eff_addr_sib()
1120 return -EINVAL; in get_eff_addr_sib()
1126 if (!insn->modrm.nbytes) in get_eff_addr_sib()
1127 return -EINVAL; in get_eff_addr_sib()
1129 if (X86_MODRM_MOD(insn->modrm.value) > 2) in get_eff_addr_sib()
1130 return -EINVAL; in get_eff_addr_sib()
1136 if (!insn->sib.nbytes) in get_eff_addr_sib()
1137 return -EINVAL; in get_eff_addr_sib()
1144 * decoding the SIB byte. Except -EDOM, which means that the registers in get_eff_addr_sib()
1147 if (*base_offset == -EDOM) in get_eff_addr_sib()
1150 return -EINVAL; in get_eff_addr_sib()
1154 if (indx_offset == -EDOM) in get_eff_addr_sib()
1157 return -EINVAL; in get_eff_addr_sib()
1161 if (insn->addr_bytes == 4) { in get_eff_addr_sib()
1167 addr32 = base32 + idx32 * (1 << X86_SIB_SCALE(insn->sib.value)); in get_eff_addr_sib()
1168 addr32 += insn->displacement.value; in get_eff_addr_sib()
1172 *eff_addr = base + indx * (1 << X86_SIB_SCALE(insn->sib.value)); in get_eff_addr_sib()
1173 *eff_addr += insn->displacement.value; in get_eff_addr_sib()
1180 * get_addr_ref_16() - Obtain the 16-bit address referred by instruction
1184 * This function is to be used with 16-bit address encodings. Obtain the memory
1186 * segment used as base is determined by either any segment override prefixes in
1194 * -1L on error.
1198 unsigned long linear_addr = -1L, seg_base, seg_limit; in get_addr_ref_16()
1206 if (insn->addr_bytes != 2) in get_addr_ref_16()
1209 if (X86_MODRM_MOD(insn->modrm.value) == 3) { in get_addr_ref_16()
1227 * is within the limits of the segment. In virtual-8086 mode, segment in get_addr_ref_16()
1228 * limits are not enforced. In such a case, the segment limit is -1L to in get_addr_ref_16()
1245 * get_addr_ref_32() - Obtain a 32-bit linear address
1249 * This function is to be used with 32-bit address encodings to obtain the
1258 * -1L on error.
1262 unsigned long linear_addr = -1L, seg_base, seg_limit; in get_addr_ref_32()
1267 if (insn->addr_bytes != 4) in get_addr_ref_32()
1270 if (X86_MODRM_MOD(insn->modrm.value) == 3) { in get_addr_ref_32()
1278 if (insn->sib.nbytes) { in get_addr_ref_32()
1299 * the effective address is within the limits of the segment. in get_addr_ref_32()
1300 * 32-bit addresses can be used in long and virtual-8086 modes if an in get_addr_ref_32()
1301 * address override prefix is used. In such cases, segment limits are in get_addr_ref_32()
1302 * not enforced. When in virtual-8086 mode, the segment limit is -1L in get_addr_ref_32()
1305 * After computed, the effective address is treated as an unsigned in get_addr_ref_32()
1312 * Even though 32-bit address encodings are allowed in virtual-8086 in get_addr_ref_32()
1313 * mode, the address range is still limited to [0x-0xffff]. in get_addr_ref_32()
1319 * Data type long could be 64 bits in size. Ensure that our 32-bit in get_addr_ref_32()
1320 * effective address is not sign-extended when computing the linear in get_addr_ref_32()
1334 * get_addr_ref_64() - Obtain a 64-bit linear address
1338 * This function is to be used with 64-bit address encodings to obtain the
1346 * -1L on error.
1351 return (void __user *)-1L; in get_addr_ref_64()
1356 unsigned long linear_addr = -1L, seg_base; in get_addr_ref_64()
1360 if (insn->addr_bytes != 8) in get_addr_ref_64()
1363 if (X86_MODRM_MOD(insn->modrm.value) == 3) { in get_addr_ref_64()
1369 if (insn->sib.nbytes) { in get_addr_ref_64()
1393 * insn_get_addr_ref() - Obtain the linear address referred by instruction
1405 * -1L on error.
1410 return (void __user *)-1L; in insn_get_addr_ref()
1412 switch (insn->addr_bytes) { in insn_get_addr_ref()
1420 return (void __user *)-1L; in insn_get_addr_ref()
1429 * If not in user-space long mode, a custom code segment could be in in insn_get_effective_ip()
1430 * use. This is true in protected mode (if the process defined a local in insn_get_effective_ip()
1431 * descriptor table), or virtual-8086 mode. In most of the cases in insn_get_effective_ip()
1436 if (seg_base == -1L) in insn_get_effective_ip()
1440 return seg_base + regs->ip; in insn_get_effective_ip()
1444 * insn_fetch_from_user() - Copy instruction bytes from user-space memory
1468 return MAX_INSN_SIZE - not_copied; in insn_fetch_from_user()
1472 * insn_fetch_from_user_inatomic() - Copy instruction bytes from user-space memory
1497 return MAX_INSN_SIZE - not_copied; in insn_fetch_from_user_inatomic()
1501 * insn_decode_from_regs() - Decode an instruction
1502 * @insn: Structure to store decoded instruction
1512 * True if instruction was decoded, False otherwise.
1522 * Override the default operand and address sizes with what is specified in insn_decode_from_regs()
1526 * have special cases where, for instance, a 16-bit code segment in insn_decode_from_regs()
1527 * descriptor is used. in insn_decode_from_regs()
1528 * If there is an address override prefix, the instruction decoder in insn_decode_from_regs()
1529 * correctly updates these values, even for 16-bit defaults. in insn_decode_from_regs()
1532 if (seg_defs == -EINVAL) in insn_decode_from_regs()
1535 insn->addr_bytes = INSN_CODE_SEG_ADDR_SZ(seg_defs); in insn_decode_from_regs()
1536 insn->opnd_bytes = INSN_CODE_SEG_OPND_SZ(seg_defs); in insn_decode_from_regs()
1541 if (buf_size < insn->length) in insn_decode_from_regs()