Merge pull request gz#40 from landhb/riscv64

Add RISCV Support

Author: gz

src/arch/mod.rs

@@ -2,6 +2,7 @@ use crate::{ElfLoaderErr, Machine};
 
 pub mod aarch64;
 pub mod arm;
+pub mod riscv;
 pub mod x86;
 pub mod x86_64;
 
@@ -15,6 +16,7 @@ pub enum RelocationType {
     x86_64(x86_64::RelocationTypes),
     Arm(arm::RelocationTypes),
     AArch64(aarch64::RelocationTypes),
+    RiscV(riscv::RelocationTypes),
 }
 
 impl RelocationType {
@@ -25,6 +27,7 @@ impl RelocationType {
             Machine::X86_64 => RelocationType::x86_64(x86_64::RelocationTypes::from(type_num)),
             Machine::Arm => RelocationType::Arm(arm::RelocationTypes::from(type_num)),
             Machine::AArch64 => RelocationType::AArch64(aarch64::RelocationTypes::from(type_num)),
+            Machine::RISC_V => RelocationType::RiscV(riscv::RelocationTypes::from(type_num)),
             _ => return Err(ElfLoaderErr::UnsupportedArchitecture),
         };
         Ok(typ)

src/arch/riscv/mod.rs

@@ -0,0 +1,183 @@
+//! RISCV relocation types
+//!
+
+#[cfg(test)]
+mod test;
+
+#[derive(Eq, PartialEq, Debug, Clone, Copy)]
+#[allow(non_camel_case_types)]
+#[repr(u32)]
+pub enum RelocationTypes {
+    /// No relocation.
+    R_RISCV_NONE,
+    /// Add 32 bit zero extended symbol value
+    R_RISCV_32,
+    /// Add 64 bit symbol value.            
+    R_RISCV_64,
+    /// Add load address of shared object.    
+    R_RISCV_RELATIVE,
+    /// Copy data from shared object.        
+    R_RISCV_COPY,
+    /// Set GOT entry to code address.
+    R_RISCV_JUMP_SLOT,
+    /// 32 bit ID of module containing symbol
+    R_RISCV_TLS_DTPMOD32,
+    /// ID of module containing symbol
+    R_RISCV_TLS_DTPMOD64,
+    /// 32 bit relative offset in TLS block
+    R_RISCV_TLS_DTPREL32,
+    /// Relative offset in TLS block
+    R_RISCV_TLS_DTPREL64,
+    /// 32 bit relative offset in static TLS block
+    R_RISCV_TLS_TPREL32,
+    /// Relative offset in static TLS block
+    R_RISCV_TLS_TPREL64,
+    /// PC-relative branch
+    R_RISCV_BRANCH,
+    /// PC-relative jump
+    R_RISCV_JAL,
+    /// PC-relative call
+    R_RISCV_CALL,
+    /// PC-relative call (PLT)
+    R_RISCV_CALL_PLT,
+    /// PC-relative GOT reference
+    R_RISCV_GOT_HI20,
+    /// PC-relative TLS IE GOT offset
+    R_RISCV_TLS_GOT_HI20,
+    /// PC-relative TLS GD reference
+    R_RISCV_TLS_GD_HI20,
+    /// PC-relative reference
+    R_RISCV_PCREL_HI20,
+    /// PC-relative reference
+    R_RISCV_PCREL_LO12_I,
+    /// PC-relative reference
+    R_RISCV_PCREL_LO12_S,
+    /// Absolute address
+    R_RISCV_HI20,
+    /// Absolute address
+    R_RISCV_LO12_I,
+    /// Absolute address  
+    R_RISCV_LO12_S,
+    /// TLS LE thread offset
+    R_RISCV_TPREL_HI20,
+    /// TLS LE thread offset
+    R_RISCV_TPREL_LO12_I,
+    /// TLS LE thread offset
+    R_RISCV_TPREL_LO12_S,
+    /// TLS LE thread usage
+    R_RISCV_TPREL_ADD,
+    /// 8-bit label addition
+    R_RISCV_ADD8,
+    /// 16-bit label addition
+    R_RISCV_ADD16,
+    /// 32-bit label addition
+    R_RISCV_ADD32,
+    /// 64-bit label addition
+    R_RISCV_ADD64,
+    /// 8-bit label subtraction
+    R_RISCV_SUB8,
+    /// 16-bit label subtraction
+    R_RISCV_SUB16,
+    /// 32-bit label subtraction
+    R_RISCV_SUB32,
+    /// 64-bit label subtraction
+    R_RISCV_SUB64,
+    /// GNU C++ vtable hierarchy
+    R_RISCV_GNU_VTINHERIT,
+    /// GNU C++ vtable member usage
+    R_RISCV_GNU_VTENTRY,
+    /// Alignment statement
+    R_RISCV_ALIGN,
+    /// PC-relative branch offset
+    R_RISCV_RVC_BRANCH,
+    /// PC-relative jump offset
+    R_RISCV_RVC_JUMP,
+    /// Absolute address
+    R_RISCV_RVC_LUI,
+    /// GP-relative reference
+    R_RISCV_GPREL_I,
+    /// GP-relative reference
+    R_RISCV_GPREL_S,
+    /// TP-relative TLS LE load
+    R_RISCV_TPREL_I,
+    /// TP-relative TLS LE store
+    R_RISCV_TPREL_S,
+    /// Instruction pair can be relaxed
+    R_RISCV_RELAX,
+    /// Local label subtraction
+    R_RISCV_SUB6,
+    /// Local label subtraction        
+    R_RISCV_SET6,
+    /// Local label subtraction
+    R_RISCV_SET8,
+    /// Local label subtraction
+    R_RISCV_SET16,
+    /// Local label subtraction
+    R_RISCV_SET32,
+
+    /// Unknown
+    Unknown(u32),
+}
+
+impl RelocationTypes {
+    /// Construct new riscv::RelocationTypes
+    pub fn from(typ: u32) -> RelocationTypes {
+        use RelocationTypes::*;
+        match typ {
+            0 => R_RISCV_NONE,
+            1 => R_RISCV_32,
+            2 => R_RISCV_64,
+            3 => R_RISCV_RELATIVE,
+            4 => R_RISCV_COPY,
+            5 => R_RISCV_JUMP_SLOT,
+            6 => R_RISCV_TLS_DTPMOD32,
+            7 => R_RISCV_TLS_DTPMOD64,
+            8 => R_RISCV_TLS_DTPREL32,
+            9 => R_RISCV_TLS_DTPREL64,
+            10 => R_RISCV_TLS_TPREL32,
+            11 => R_RISCV_TLS_TPREL64,
+            16 => R_RISCV_BRANCH,
+            17 => R_RISCV_JAL,
+            18 => R_RISCV_CALL,
+            19 => R_RISCV_CALL_PLT,
+            20 => R_RISCV_GOT_HI20,
+            21 => R_RISCV_TLS_GOT_HI20,
+            22 => R_RISCV_TLS_GD_HI20,
+            23 => R_RISCV_PCREL_HI20,
+            24 => R_RISCV_PCREL_LO12_I,
+            25 => R_RISCV_PCREL_LO12_S,
+            26 => R_RISCV_HI20,
+            27 => R_RISCV_LO12_I,
+            28 => R_RISCV_LO12_S,
+            29 => R_RISCV_TPREL_HI20,
+            30 => R_RISCV_TPREL_LO12_I,
+            31 => R_RISCV_TPREL_LO12_S,
+            32 => R_RISCV_TPREL_ADD,
+            33 => R_RISCV_ADD8,
+            34 => R_RISCV_ADD16,
+            35 => R_RISCV_ADD32,
+            36 => R_RISCV_ADD64,
+            37 => R_RISCV_SUB8,
+            38 => R_RISCV_SUB16,
+            39 => R_RISCV_SUB32,
+            40 => R_RISCV_SUB64,
+            41 => R_RISCV_GNU_VTINHERIT,
+            42 => R_RISCV_GNU_VTENTRY,
+            43 => R_RISCV_ALIGN,
+            44 => R_RISCV_RVC_BRANCH,
+            45 => R_RISCV_RVC_JUMP,
+            46 => R_RISCV_RVC_LUI,
+            47 => R_RISCV_GPREL_I,
+            48 => R_RISCV_GPREL_S,
+            49 => R_RISCV_TPREL_I,
+            50 => R_RISCV_TPREL_S,
+            51 => R_RISCV_RELAX,
+            52 => R_RISCV_SUB6,
+            53 => R_RISCV_SET6,
+            54 => R_RISCV_SET8,
+            55 => R_RISCV_SET16,
+            56 => R_RISCV_SET32,
+            x => Unknown(x),
+        }
+    }
+}

src/arch/riscv/test.rs

@@ -0,0 +1,127 @@
+use std::fs;
+
+use crate::arch::test::*;
+use crate::*;
+
+#[test]
+fn load_pie_elf() {
+    init();
+    let binary_blob = fs::read("test/test.riscv64").expect("Can't read binary");
+    let binary = ElfBinary::new(binary_blob.as_slice()).expect("Got proper ELF file");
+
+    assert!(binary.is_pie());
+
+    let mut loader = TestLoader::new(0x1000_0000);
+    binary.load(&mut loader).expect("Can't load?");
+
+    for action in loader.actions.iter() {
+        println!("{:?}", action);
+    }
+
+    // View allocate/load actions with readelf -l [binary]
+    // Program Headers:
+    // Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+    // PHDR           0x000040 0x0000000000000040 0x0000000000000040 0x000188 0x000188 R   0x8
+    // INTERP         0x0001c8 0x00000000000001c8 0x00000000000001c8 0x00001a 0x00001a R   0x1
+    // [Requesting program interpreter: /lib/ld-linux-aarch64.so.1]
+    // LOAD           0x000000 0x0000000000000000 0x0000000000000000 0x000780 0x000780 R E 0x10000
+    // LOAD           0x000e20 0x0000000000001e20 0x0000000000001e20 0x000250 0x000288 RW  0x10000
+    // DYNAMIC        0x000e30 0x0000000000001e30 0x0000000000001e30 0x0001d0 0x0001d0 RW  0x8
+    assert_eq!(
+        loader.actions[0],
+        LoaderAction::Allocate(VAddr::from(0x0u64), 0x780, Flags(1 | 4))
+    );
+    assert_eq!(
+        loader.actions[1],
+        LoaderAction::Allocate(VAddr::from(0x1e20u64), 0x288, Flags(0b110))
+    );
+    assert_eq!(
+        loader.actions[2],
+        LoaderAction::Load(VAddr::from(0x0u64), 0x780)
+    );
+    assert_eq!(
+        loader.actions[3],
+        LoaderAction::Load(VAddr::from(0x1e20u64), 0x250)
+    );
+
+    // View relocation actions with readelf -r [binary]
+    //
+    // Relocation section '.rela.dyn' at offset 0x420 contains 11 entries:
+    //   Offset          Info           Type           Sym. Value    Sym. Name + Addend
+    // 000000001e20  000000000003 R_RISCV_RELATIVE                     6ac
+    // 000000001e28  000000000003 R_RISCV_RELATIVE                     644
+    // 000000002000  000000000003 R_RISCV_RELATIVE                     2000
+    // 000000002058  000000000003 R_RISCV_RELATIVE                     6e0
+    // 000000002030  000300000002 R_RISCV_64        0000000000000000 __cxa_finalize + 0
+    // 000000002038  000400000002 R_RISCV_64        0000000000000000 _init + 0
+    // 000000002040  000500000002 R_RISCV_64        0000000000000000 __deregister_fram[...] + 0
+    // 000000002048  000600000002 R_RISCV_64        0000000000000000 _ITM_registerTMCl[...] + 0
+    // 000000002050  000700000002 R_RISCV_64        0000000000000000 _ITM_deregisterTM[...] + 0
+    // 000000002060  000800000002 R_RISCV_64        0000000000000000 _fini + 0
+    // 000000002068  000a00000002 R_RISCV_64        0000000000000000 __register_frame_info + 0
+    //
+    // Relocation section '.rela.plt' at offset 0x528 contains 2 entries:
+    //   Offset          Info           Type           Sym. Value    Sym. Name + Addend
+    // 000000002018  000200000005 R_RISCV_JUMP_SLOT 0000000000000000 printf + 0
+    // 000000002020  000900000005 R_RISCV_JUMP_SLOT 0000000000000000 __libc_start_main + 0
+    assert_eq!(
+        loader.actions[4],
+        LoaderAction::Relocate(0x1000_0000 + 0x1e20, 0x1000_06ac)
+    );
+    assert_eq!(
+        loader.actions[5],
+        LoaderAction::Relocate(0x1000_0000 + 0x1e28, 0x1000_0644)
+    );
+    assert_eq!(
+        loader.actions[6],
+        LoaderAction::Relocate(0x1000_0000 + 0x2000, 0x1000_2000)
+    );
+    assert_eq!(
+        loader.actions[7],
+        LoaderAction::Relocate(0x1000_0000 + 0x2058, 0x1000_06e0)
+    );
+
+    assert_eq!(loader.actions.len(), 8);
+}
+
+#[test]
+fn check_nopie() {
+    init();
+    let binary_blob = fs::read("test/test_nopie.riscv64").expect("Can't read binary");
+    let binary = ElfBinary::new(binary_blob.as_slice()).expect("Got proper ELF file");
+
+    assert!(!binary.is_pie());
+}
+
+#[test]
+fn check_tls() {
+    init();
+
+    let binary_blob = fs::read("test/tls.riscv64").expect("Can't read binary");
+    let binary = ElfBinary::new(binary_blob.as_slice()).expect("Got proper ELF file");
+    let mut loader = TestLoader::new(0x1000_0000);
+    binary.load(&mut loader).expect("Can't load?");
+    /*
+    readelf -l test/tls.riscv64
+    TLS produces entries of this form:
+    pheader = Program header:
+    type:             Ok(Tls)
+    flags:              R
+    offset:           0xe20
+    virtual address:  0x1e0c
+    physical address: 0x1e0c
+    file size:        0x4
+    memory size:      0x8
+    align:            0x4
+
+    File size is 0x4 because we have one tdata entry; memory size
+    is 8 because we also have one bss entry that needs to be written with zeroes.
+    So to initialize TLS: we allocate zeroed memory of size `memory size`, then copy
+    file size starting at virtual address in the beginning.
+    */
+    assert!(loader
+        .actions
+        .iter()
+        .find(|&&x| x == LoaderAction::Tls(VAddr::from(0x1e0cu64), 0x4, 0x8, 0x4))
+        .is_some());
+}

src/arch/test.rs

@@ -44,9 +44,10 @@ impl ElfLoader for TestLoader {
 
     fn relocate(&mut self, entry: RelocationEntry) -> Result<(), ElfLoaderErr> {
         use crate::arch::aarch64::RelocationTypes::*;
+        use crate::arch::riscv::RelocationTypes::*;
         use crate::arch::x86::RelocationTypes::*;
         use crate::arch::x86_64::RelocationTypes::*;
-        use RelocationType::{x86, x86_64, AArch64};
+        use RelocationType::{x86, x86_64, AArch64, RiscV};
 
         // Get the pointer to where the relocation happens in the
         // memory where we loaded the headers
@@ -72,6 +73,22 @@ impl ElfLoader for TestLoader {
                 Ok(())
             }
             x86(R_386_NONE) => Ok(()),
+            // RISCV
+            RiscV(R_RISCV_64) => Ok(()),
+            RiscV(R_RISCV_NONE) => Ok(()),
+            RiscV(R_RISCV_RELATIVE) => {
+                // This type requires addend to be present
+                let addend = entry
+                    .addend
+                    .ok_or(ElfLoaderErr::UnsupportedRelocationEntry)?;
+
+                // This is a relative relocation, add the offset (where we put our
+                // binary in the vspace) to the addend and we're done.
+                self.actions
+                    .push(LoaderAction::Relocate(addr as u64, self.vbase + addend));
+                trace!("R_RELATIVE *{:p} = {:#x}", addr, self.vbase + addend);
+                Ok(())
+            }
 
             // x86_64
             x86_64(R_AMD64_64) => {