Method display_literals

objdiff-core/src/arch/mod.rs:120–264

(&self, endian: object::Endianness, bytes: &[u8])

    }

    pub fn display_literals(&self, endian: object::Endianness, bytes: &[u8]) -> Vec<LiteralInfo> {
        let mut strs = Vec::new();
        if self.required_len().is_some_and(|l| bytes.len() < l) {
            log::warn!(
                "Failed to display a symbol value for a symbol whose size is too small for instruction referencing it."
            );
            return strs;
        }
        let mut bytes = bytes;
        if self.required_len().is_some_and(|l| bytes.len() > l) {
            // If the symbol's size is larger a single instance of this data type, we take just the
            // bytes necessary for one of them in order to display the first element of the array.
            bytes = &bytes[0..self.required_len().unwrap()];
            // TODO: Attempt to interpret large symbols as arrays of a smaller type and show all
            // elements of the array instead. https://github.com/encounter/objdiff/issues/124
            // However, note that the stride of an array can not always be determined just by the
            // data type guessed by the single instruction accessing it. There can also be arrays of
            // structs that contain multiple elements of different types, so if other elements after
            // the first one were to be displayed in this manner, they may be inaccurate.
        }

        match self {
            DataType::Int8 => {
                let i = i8::from_ne_bytes(bytes.try_into().unwrap());
                strs.push(LiteralInfo { literal: format!("{i:#x}"), ..Default::default() });

                if i < 0 {
                    strs.push(LiteralInfo {
                        literal: format!("{:#x}", ReallySigned(i)),
                        ..Default::default()
                    });
                }
            }
            DataType::Int16 => {
                let i = endian.read_i16_bytes(bytes.try_into().unwrap());
                strs.push(LiteralInfo { literal: format!("{i:#x}"), ..Default::default() });

                if i < 0 {
                    strs.push(LiteralInfo {
                        literal: format!("{:#x}", ReallySigned(i)),
                        ..Default::default()
                    });
                }
            }
            DataType::Int32 => {
                let i = endian.read_i32_bytes(bytes.try_into().unwrap());
                strs.push(LiteralInfo { literal: format!("{i:#x}"), ..Default::default() });

                if i < 0 {
                    strs.push(LiteralInfo {
                        literal: format!("{:#x}", ReallySigned(i)),
                        ..Default::default()
                    });
                }
            }
            DataType::Int64 => {
                let i = endian.read_i64_bytes(bytes.try_into().unwrap());
                strs.push(LiteralInfo { literal: format!("{i:#x}"), ..Default::default() });