Added armv7-linux-gnueabihf support.

Some more stuff was pulled into arch-specific modules, since
arm/x86 differ.
Began work for making function abort code part of the function.

Author: zachs18

src/code.rs

@@ -62,6 +62,10 @@ impl std::ops::AddAssign for Relocatable {
         let lhs_len = self.data.len();
         self.data.to_mut().extend_from_slice(&rhs.data);
 
+        self.abs_symbols.extend(rhs.abs_symbols.into_iter().map(
+            |(sym, val)| (sym, val)
+        ));
+
         self.symbols.extend(rhs.symbols.into_iter().map(
             |(sym, loc)| (sym, loc + lhs_len)
         ));

src/code/arch/arm.rs

@@ -0,0 +1,87 @@
+use crate::code::AssembleError;
+
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum RelocationKind {
+    None = 0,
+    Jump24 = 29,
+    Movw,
+    Movt,
+}
+
+impl RelocationKind {
+    /// Addend has already been applied to value
+    pub(crate) fn apply_relative(self, data: &mut [u8], location: usize, value: usize) -> Result<(), AssembleError> {
+        use RelocationKind::*;
+        let value: isize = if location < value {
+            (value - location).try_into().ok().ok_or(AssembleError::InvalidRelocation("Relative relocation difference too large"))?
+        } else {
+            -(location - value).try_into().ok().ok_or(AssembleError::InvalidRelocation("Relative relocation difference too large"))?
+        };
+        match self {
+            None => Ok(()),
+            Jump24 => {
+                // Low 24 bits of (big-endian) word contain low 26 bits of pc-relative address (00 on the end) (sign-extended)
+                let instruction: &mut [u8; 4] = data.get_mut(location..location+4)
+                    .ok_or(AssembleError::InvalidRelocation("Attempted to apply relocation past end of section"))?
+                    .try_into().unwrap();
+                if value & 3 != 0{
+                    return Err(AssembleError::InvalidRelocation("Relative relocation cut off low bits"));
+                }
+                let actual_value = value >> 2;
+                let actual_value: i32 = actual_value.try_into().ok().ok_or(AssembleError::InvalidRelocation("Relative relocation difference too large"))?;
+                let bytes = i32::to_le_bytes(actual_value);
+                if !(
+                    (bytes[3] == 0x00 && bytes[2] & 0x80 == 0x00) ||
+                    (bytes[3] == 0xFF && bytes[2] & 0x80 == 0x80)
+                ) {
+                    return Err(AssembleError::InvalidRelocation("Relative relocation difference too large"));
+                }
+                instruction[..3].copy_from_slice(&bytes[..3]);
+                Ok(())
+            },
+            Movw | Movt => Err(AssembleError::InvalidRelocation("Cannot apply direct relocation for relative symbol")),
+        }
+    }
+    pub(crate) fn apply_absolute(self, data: &mut [u8], location: usize, value: isize) -> Result<(), AssembleError> {
+        use RelocationKind::*;
+        match self {
+            None => Ok(()),
+            Jump24 => Err(AssembleError::InvalidRelocation("Cannot apply relative relocation for absolute symbol")),
+            Movw => {
+                // Low 16 bits of value encoded in bits 19-16 and 11-0 of the 4-byte big-endian instruction
+                let instruction: &mut [u8; 4] = data.get_mut(location..location+4)
+                    .ok_or(AssembleError::InvalidRelocation("Attempted to apply relocation past end of section"))?
+                    .try_into().unwrap();
+                let actual_value: i32 = value.try_into().ok().ok_or(AssembleError::InvalidRelocation("Relative relocation difference too large"))?;
+                let low_half: u16 = actual_value as u32 as u16;
+                let imm4: u8 = (low_half >> 12) as u8 & 0xF;
+                let imm12: u16 = low_half & 0xFFF;
+                let imm12_bytes = imm12.to_be_bytes();
+                instruction[2] &= 0xF0;
+                instruction[2] |= imm4;
+                instruction[1] &= 0xF0;
+                instruction[1] |= imm12_bytes[0];
+                instruction[0] = imm12_bytes[1];
+                Ok(())
+            },
+            Movt => {
+                // Low 16 bits of value encoded in bits 19-16 and 11-0 of the 4-byte big-endian instruction
+                let instruction: &mut [u8; 4] = data.get_mut(location..location+4)
+                    .ok_or(AssembleError::InvalidRelocation("Attempted to apply relocation past end of section"))?
+                    .try_into().unwrap();
+                let actual_value: i32 = value.try_into().ok().ok_or(AssembleError::InvalidRelocation("Relative relocation difference too large"))?;
+                let high_half: u16 = (actual_value as u32 >> 16) as u16;
+                let imm4: u8 = (high_half >> 12) as u8 & 0xF;
+                let imm12: u16 = high_half & 0xFFF;
+                let imm12_bytes = imm12.to_be_bytes();
+                instruction[2] &= 0xF0;
+                instruction[2] |= imm4;
+                instruction[1] &= 0xF0;
+                instruction[1] |= imm12_bytes[0];
+                instruction[0] = imm12_bytes[1];
+                Ok(())
+            },
+        }
+    }
+}

src/code/symbol.rs

@@ -2,6 +2,7 @@ use std::sync::atomic::AtomicUsize;
 
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 enum SymbolInner {
+    Abort,
     Local(usize),
     Global(String),
 }
@@ -21,12 +22,16 @@ impl Symbol {
         let idx = LOCAL_COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
         Symbol { inner: SymbolInner::Local(idx) }
     }
+    pub fn abort() -> Self {
+        Symbol { inner: SymbolInner::Abort }
+    }
 }
 
 impl std::fmt::Debug for Symbol {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         use SymbolInner::*;
         match &self.inner {
+            Abort => write!(f, "\".Labort\""),
             Local(idx) => write!(f, "\".L{}\"", idx),
             Global(sym) => write!(f, "{:?}", sym),
         }
@@ -37,6 +42,7 @@ impl std::fmt::Display for Symbol {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         use SymbolInner::*;
         match &self.inner {
+            Abort => write!(f, ".Labort"),
             Local(idx) => write!(f, ".L{}", idx),
             Global(sym) => write!(f, "{}", sym),
         }