diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/display.rs | 113 | ||||
| -rw-r--r-- | src/lib.rs | 33 | 
2 files changed, 87 insertions, 59 deletions
diff --git a/src/display.rs b/src/display.rs index 0694265..1c5792e 100644 --- a/src/display.rs +++ b/src/display.rs @@ -706,75 +706,78 @@ impl <T: std::fmt::Write> ShowContextual<u64, [Option<String>], T> for Instructi                  x.colorize(colors, out)?;              }          }; -        match self.opcode { -            Opcode::MOVSX_b | -            Opcode::MOVZX_b => { -                match context.and_then(|xs| xs[1].as_ref()) { -                    Some(s) => { write!(out, ", {}", s) } -                    None => { -                        match &self.operands[1] { -                            &OperandSpec::Nothing => { -                                unreachable!(); -                            }, -                            &OperandSpec::RegMMM => { -                                write!(out, ", ")?; -                            } -                            x @ _ => { -                                write!(out, ", byte ")?; -                                if let Some(prefix) = self.segment_override_for_op(1) { -                                    write!(out, "{}:", prefix)?; +        for i in 1..4 { +            match self.opcode { +                Opcode::MOVSX_b | +                Opcode::MOVZX_b => { +                    match context.and_then(|xs| xs[i].as_ref()) { +                        Some(s) => { write!(out, ", {}", s)? } +                        None => { +                            match &self.operands[i] { +                                &OperandSpec::Nothing => { +                                    return Ok(()); +                                }, +                                &OperandSpec::RegMMM => { +                                    write!(out, ", ")?; +                                } +                                x @ _ => { +                                    write!(out, ", byte ")?; +                                    if let Some(prefix) = self.segment_override_for_op(1) { +                                        write!(out, "{}:", prefix)?; +                                    }                                  }                              } +                            let x = Operand::from_spec(self, self.operands[i]); +                            x.colorize(colors, out)?                          } -                        let x = Operand::from_spec(self, self.operands[1]); -                        x.colorize(colors, out)                      } -                } -            }, -            Opcode::MOVSX_w | -            Opcode::MOVZX_w => { -                match context.and_then(|xs| xs[1].as_ref()) { -                    Some(s) => { write!(out, ", {}", s) } -                    None => { -                        match &self.operands[1] { -                            &OperandSpec::Nothing => { -                                unreachable!(); -                            }, -                            &OperandSpec::RegMMM => { -                                write!(out, ", ")?; -                            } -                            _ => { -                                write!(out, ", word ")?; -                                if let Some(prefix) = self.segment_override_for_op(1) { -                                    write!(out, "{}:", prefix)?; +                }, +                Opcode::MOVSX_w | +                Opcode::MOVZX_w => { +                    match context.and_then(|xs| xs[i].as_ref()) { +                        Some(s) => { write!(out, ", {}", s)? } +                        None => { +                            match &self.operands[i] { +                                &OperandSpec::Nothing => { +                                    return Ok(()); +                                }, +                                &OperandSpec::RegMMM => { +                                    write!(out, ", ")?; +                                } +                                _ => { +                                    write!(out, ", word ")?; +                                    if let Some(prefix) = self.segment_override_for_op(1) { +                                        write!(out, "{}:", prefix)?; +                                    }                                  }                              } +                            let x = Operand::from_spec(self, self.operands[i]); +                            x.colorize(colors, out)?                          } -                        let x = Operand::from_spec(self, self.operands[1]); -                        x.colorize(colors, out)                      } -                } -            }, -            _ => { -                match context.and_then(|xs| xs[1].as_ref()) { -                    Some(s) => { write!(out, ", {}", s) } -                    None => { -                        match &self.operands[1] { -                            &OperandSpec::Nothing => { -                                return Ok(()); -                            }, -                            _ => { -                                write!(out, ", ")?; -                                if let Some(prefix) = self.segment_override_for_op(1) { -                                    write!(out, "{}:", prefix)?; +                }, +                _ => { +                    match context.and_then(|xs| xs[i].as_ref()) { +                        Some(s) => { write!(out, ", {}", s)? } +                        None => { +                            match &self.operands[i] { +                                &OperandSpec::Nothing => { +                                    return Ok(()); +                                }, +                                _ => { +                                    write!(out, ", ")?; +                                    if let Some(prefix) = self.segment_override_for_op(1) { +                                        write!(out, "{}:", prefix)?; +                                    } +                                    let x = Operand::from_spec(self, self.operands[i]); +                                    x.colorize(colors, out)?                                  } -                                let x = Operand::from_spec(self, self.operands[1]); -                                x.colorize(colors, out)                              }                          }                      }                  }              }          } +        Ok(())      }  } @@ -1522,7 +1522,6 @@ fn read_opcode_f20f_map<T: Iterator<Item=u8>>(bytes_iter: &mut T, length: &mut u              Some(record)          }          None => { -            unsafe { unreachable_unchecked(); }              None          }      } @@ -1810,7 +1809,6 @@ fn read_opcode_f30f_map<T: Iterator<Item=u8>>(bytes_iter: &mut T, length: &mut u              Some(record)          }          None => { -            unsafe { unreachable_unchecked(); }              None          }      } @@ -2139,7 +2137,6 @@ fn read_opcode_0f_map<T: Iterator<Item=u8>>(bytes_iter: &mut T, length: &mut u8)              Some(record)          }          None => { -            unsafe { unreachable_unchecked(); }              None          }      } @@ -2806,7 +2803,11 @@ pub fn read_operands<T: Iterator<Item=u8>>(mut bytes_iter: T, instruction: &mut              }          } else {              opwidth = 1; -            bank = RegisterBank::B; +            if instruction.prefixes.rex().present() { +                bank = RegisterBank::rB; +            } else { +                bank = RegisterBank::B; +            }          };          modrm = read_modrm(&mut bytes_iter, instruction, length)?;          instruction.modrm_rrr = @@ -3017,6 +3018,7 @@ pub fn read_operands<T: Iterator<Item=u8>>(mut bytes_iter: T, instruction: &mut                      instruction.imm = read_imm_signed(&mut bytes_iter, numwidth, length)? as u64;                      bytes_read = numwidth;                      instruction.operands[1] = match opwidth { +                        1 => OperandSpec::ImmI8,                          2 => OperandSpec::ImmI16,                          4 => OperandSpec::ImmI32,                          8 => OperandSpec::ImmI64, @@ -3192,6 +3194,29 @@ pub fn read_operands<T: Iterator<Item=u8>>(mut bytes_iter: T, instruction: &mut              instruction.operand_count = 1;              instruction.operands[0] = OperandSpec::ImmI32;          } +        OperandCode::Gb_Eb_Ib => { +            instruction.operands[0] = OperandSpec::RegRRR; +            instruction.operands[1] = mem_oper; +            instruction.imm = +                read_imm_signed(&mut bytes_iter, 1, length)? as u64; +            instruction.operands[2] = OperandSpec::ImmI8; +            instruction.operand_count = 3; +        } +        OperandCode::Gv_Ev_Iv => { +            let opwidth = imm_width_from_prefixes_64(SizeCode::vqp, instruction.prefixes); +            let numwidth = if opwidth == 8 { 4 } else { opwidth }; +            instruction.operands[0] = OperandSpec::RegRRR; +            instruction.operands[1] = mem_oper; +            instruction.imm = +                read_imm_signed(&mut bytes_iter, numwidth, length)? as u64; +            instruction.operands[2] = match opwidth { +                2 => OperandSpec::ImmI16, +                4 => OperandSpec::ImmI32, +                8 => OperandSpec::ImmI64, +                _ => unsafe { unreachable_unchecked() } +            }; +            instruction.operand_count = 3; +        }          OperandCode::Nothing => {              instruction.operand_count = 0;          }  | 
