Skip to main content

Section

synth_backend::elf_builder

Struct Section 

Source 
pub struct Section {
    pub name: String,
    pub section_type: SectionType,
    pub flags: u32,
    pub addr: u32,
    pub data: Vec<u8>,
    pub align: u32,
    pub explicit_size: Option<u32>,
}
Expand description

ELF section

Fields§

§name: String

Section name (index into string table)

§section_type: SectionType

Section type

§flags: u32

Section flags

§addr: u32

Virtual address

§data: Vec<u8>

Section data

§align: u32

Alignment

§explicit_size: Option<u32>

Explicit size (for NoBits sections like .bss where data is empty)

Implementations§

Source§

impl Section

Source

pub fn new(name: &str, section_type: SectionType) -> Self

Create a new section

Examples found in repository?
examples/compile_add.rs (line 68)
17fn main() -> Result<(), Box<dyn std::error::Error>> {
18    println!("=== Synth Minimal Demo: WASM -> ARM ELF ===\n");
19
20    // Step 1: Define WASM operations for add(a, b) function
21    // Equivalent to: (func (param $a i32) (param $b i32) (result i32)
22    //                  local.get $a
23    //                  local.get $b
24    //                  i32.add)
25    let wasm_ops = vec![
26        WasmOp::LocalGet(0), // Load param a
27        WasmOp::LocalGet(1), // Load param b
28        WasmOp::I32Add,      // Add them
29    ];
30
31    println!("Step 1: WASM Operations");
32    println!("  Input: add(a, b) = a + b");
33    println!("  WASM ops: {:?}\n", wasm_ops);
34
35    // Step 2: Select ARM instructions
36    let db = RuleDatabase::with_standard_rules();
37    let mut selector = InstructionSelector::new(db.rules().to_vec());
38    let arm_instrs = selector.select(&wasm_ops)?;
39
40    println!("Step 2: ARM Instruction Selection");
41    println!("  Generated {} ARM instructions:", arm_instrs.len());
42    for (i, instr) in arm_instrs.iter().enumerate() {
43        println!("    {}: {:?}", i, instr.op);
44    }
45    println!();
46
47    // Step 3: Encode to ARM binary
48    let encoder = ArmEncoder::new_arm32();
49    let mut code = Vec::new();
50
51    for instr in &arm_instrs {
52        let encoded = encoder.encode(&instr.op)?;
53        code.extend_from_slice(&encoded);
54    }
55
56    println!("Step 3: ARM Binary Encoding");
57    println!("  Generated {} bytes of machine code", code.len());
58    print!("  Hex: ");
59    for byte in &code {
60        print!("{:02x} ", byte);
61    }
62    println!("\n");
63
64    // Step 4: Build ELF file
65    let mut elf_builder = ElfBuilder::new_arm32().with_entry(0x8000);
66
67    // Add .text section with code
68    let text_section = Section::new(".text", ElfSectionType::ProgBits)
69        .with_flags(SectionFlags::ALLOC | SectionFlags::EXEC)
70        .with_addr(0x8000)
71        .with_align(4)
72        .with_data(code.clone());
73
74    elf_builder.add_section(text_section);
75
76    // Add function symbol
77    let add_sym = Symbol::new("add")
78        .with_value(0x8000)
79        .with_size(code.len() as u32)
80        .with_binding(SymbolBinding::Global)
81        .with_type(SymbolType::Func)
82        .with_section(4);
83
84    elf_builder.add_symbol(add_sym);
85
86    // Build ELF
87    let elf_data = elf_builder.build()?;
88
89    println!("Step 4: ELF Generation");
90    println!("  ELF size: {} bytes", elf_data.len());
91    println!("  Entry point: 0x8000");
92
93    // Verify ELF header
94    assert_eq!(
95        &elf_data[0..4],
96        &[0x7f, b'E', b'L', b'F'],
97        "Invalid ELF magic"
98    );
99    println!("  ELF magic: valid");
100
101    // Step 5: Write to file
102    let output_path = "add.elf";
103    let mut file = File::create(output_path)?;
104    file.write_all(&elf_data)?;
105
106    println!("\nStep 5: Output");
107    println!("  Written to: {}", output_path);
108    println!("\n=== Compilation successful! ===");
109    println!("\nTo inspect: arm-none-eabi-objdump -d {}", output_path);
110
111    Ok(())
112}
Source

pub fn with_flags(self, flags: u32) -> Self

Set flags

Examples found in repository?
examples/compile_add.rs (line 69)
17fn main() -> Result<(), Box<dyn std::error::Error>> {
18    println!("=== Synth Minimal Demo: WASM -> ARM ELF ===\n");
19
20    // Step 1: Define WASM operations for add(a, b) function
21    // Equivalent to: (func (param $a i32) (param $b i32) (result i32)
22    //                  local.get $a
23    //                  local.get $b
24    //                  i32.add)
25    let wasm_ops = vec![
26        WasmOp::LocalGet(0), // Load param a
27        WasmOp::LocalGet(1), // Load param b
28        WasmOp::I32Add,      // Add them
29    ];
30
31    println!("Step 1: WASM Operations");
32    println!("  Input: add(a, b) = a + b");
33    println!("  WASM ops: {:?}\n", wasm_ops);
34
35    // Step 2: Select ARM instructions
36    let db = RuleDatabase::with_standard_rules();
37    let mut selector = InstructionSelector::new(db.rules().to_vec());
38    let arm_instrs = selector.select(&wasm_ops)?;
39
40    println!("Step 2: ARM Instruction Selection");
41    println!("  Generated {} ARM instructions:", arm_instrs.len());
42    for (i, instr) in arm_instrs.iter().enumerate() {
43        println!("    {}: {:?}", i, instr.op);
44    }
45    println!();
46
47    // Step 3: Encode to ARM binary
48    let encoder = ArmEncoder::new_arm32();
49    let mut code = Vec::new();
50
51    for instr in &arm_instrs {
52        let encoded = encoder.encode(&instr.op)?;
53        code.extend_from_slice(&encoded);
54    }
55
56    println!("Step 3: ARM Binary Encoding");
57    println!("  Generated {} bytes of machine code", code.len());
58    print!("  Hex: ");
59    for byte in &code {
60        print!("{:02x} ", byte);
61    }
62    println!("\n");
63
64    // Step 4: Build ELF file
65    let mut elf_builder = ElfBuilder::new_arm32().with_entry(0x8000);
66
67    // Add .text section with code
68    let text_section = Section::new(".text", ElfSectionType::ProgBits)
69        .with_flags(SectionFlags::ALLOC | SectionFlags::EXEC)
70        .with_addr(0x8000)
71        .with_align(4)
72        .with_data(code.clone());
73
74    elf_builder.add_section(text_section);
75
76    // Add function symbol
77    let add_sym = Symbol::new("add")
78        .with_value(0x8000)
79        .with_size(code.len() as u32)
80        .with_binding(SymbolBinding::Global)
81        .with_type(SymbolType::Func)
82        .with_section(4);
83
84    elf_builder.add_symbol(add_sym);
85
86    // Build ELF
87    let elf_data = elf_builder.build()?;
88
89    println!("Step 4: ELF Generation");
90    println!("  ELF size: {} bytes", elf_data.len());
91    println!("  Entry point: 0x8000");
92
93    // Verify ELF header
94    assert_eq!(
95        &elf_data[0..4],
96        &[0x7f, b'E', b'L', b'F'],
97        "Invalid ELF magic"
98    );
99    println!("  ELF magic: valid");
100
101    // Step 5: Write to file
102    let output_path = "add.elf";
103    let mut file = File::create(output_path)?;
104    file.write_all(&elf_data)?;
105
106    println!("\nStep 5: Output");
107    println!("  Written to: {}", output_path);
108    println!("\n=== Compilation successful! ===");
109    println!("\nTo inspect: arm-none-eabi-objdump -d {}", output_path);
110
111    Ok(())
112}
Source

pub fn with_addr(self, addr: u32) -> Self

Set address

Examples found in repository?
examples/compile_add.rs (line 70)
17fn main() -> Result<(), Box<dyn std::error::Error>> {
18    println!("=== Synth Minimal Demo: WASM -> ARM ELF ===\n");
19
20    // Step 1: Define WASM operations for add(a, b) function
21    // Equivalent to: (func (param $a i32) (param $b i32) (result i32)
22    //                  local.get $a
23    //                  local.get $b
24    //                  i32.add)
25    let wasm_ops = vec![
26        WasmOp::LocalGet(0), // Load param a
27        WasmOp::LocalGet(1), // Load param b
28        WasmOp::I32Add,      // Add them
29    ];
30
31    println!("Step 1: WASM Operations");
32    println!("  Input: add(a, b) = a + b");
33    println!("  WASM ops: {:?}\n", wasm_ops);
34
35    // Step 2: Select ARM instructions
36    let db = RuleDatabase::with_standard_rules();
37    let mut selector = InstructionSelector::new(db.rules().to_vec());
38    let arm_instrs = selector.select(&wasm_ops)?;
39
40    println!("Step 2: ARM Instruction Selection");
41    println!("  Generated {} ARM instructions:", arm_instrs.len());
42    for (i, instr) in arm_instrs.iter().enumerate() {
43        println!("    {}: {:?}", i, instr.op);
44    }
45    println!();
46
47    // Step 3: Encode to ARM binary
48    let encoder = ArmEncoder::new_arm32();
49    let mut code = Vec::new();
50
51    for instr in &arm_instrs {
52        let encoded = encoder.encode(&instr.op)?;
53        code.extend_from_slice(&encoded);
54    }
55
56    println!("Step 3: ARM Binary Encoding");
57    println!("  Generated {} bytes of machine code", code.len());
58    print!("  Hex: ");
59    for byte in &code {
60        print!("{:02x} ", byte);
61    }
62    println!("\n");
63
64    // Step 4: Build ELF file
65    let mut elf_builder = ElfBuilder::new_arm32().with_entry(0x8000);
66
67    // Add .text section with code
68    let text_section = Section::new(".text", ElfSectionType::ProgBits)
69        .with_flags(SectionFlags::ALLOC | SectionFlags::EXEC)
70        .with_addr(0x8000)
71        .with_align(4)
72        .with_data(code.clone());
73
74    elf_builder.add_section(text_section);
75
76    // Add function symbol
77    let add_sym = Symbol::new("add")
78        .with_value(0x8000)
79        .with_size(code.len() as u32)
80        .with_binding(SymbolBinding::Global)
81        .with_type(SymbolType::Func)
82        .with_section(4);
83
84    elf_builder.add_symbol(add_sym);
85
86    // Build ELF
87    let elf_data = elf_builder.build()?;
88
89    println!("Step 4: ELF Generation");
90    println!("  ELF size: {} bytes", elf_data.len());
91    println!("  Entry point: 0x8000");
92
93    // Verify ELF header
94    assert_eq!(
95        &elf_data[0..4],
96        &[0x7f, b'E', b'L', b'F'],
97        "Invalid ELF magic"
98    );
99    println!("  ELF magic: valid");
100
101    // Step 5: Write to file
102    let output_path = "add.elf";
103    let mut file = File::create(output_path)?;
104    file.write_all(&elf_data)?;
105
106    println!("\nStep 5: Output");
107    println!("  Written to: {}", output_path);
108    println!("\n=== Compilation successful! ===");
109    println!("\nTo inspect: arm-none-eabi-objdump -d {}", output_path);
110
111    Ok(())
112}
Source

pub fn with_align(self, align: u32) -> Self

Set alignment

Examples found in repository?
examples/compile_add.rs (line 71)
17fn main() -> Result<(), Box<dyn std::error::Error>> {
18    println!("=== Synth Minimal Demo: WASM -> ARM ELF ===\n");
19
20    // Step 1: Define WASM operations for add(a, b) function
21    // Equivalent to: (func (param $a i32) (param $b i32) (result i32)
22    //                  local.get $a
23    //                  local.get $b
24    //                  i32.add)
25    let wasm_ops = vec![
26        WasmOp::LocalGet(0), // Load param a
27        WasmOp::LocalGet(1), // Load param b
28        WasmOp::I32Add,      // Add them
29    ];
30
31    println!("Step 1: WASM Operations");
32    println!("  Input: add(a, b) = a + b");
33    println!("  WASM ops: {:?}\n", wasm_ops);
34
35    // Step 2: Select ARM instructions
36    let db = RuleDatabase::with_standard_rules();
37    let mut selector = InstructionSelector::new(db.rules().to_vec());
38    let arm_instrs = selector.select(&wasm_ops)?;
39
40    println!("Step 2: ARM Instruction Selection");
41    println!("  Generated {} ARM instructions:", arm_instrs.len());
42    for (i, instr) in arm_instrs.iter().enumerate() {
43        println!("    {}: {:?}", i, instr.op);
44    }
45    println!();
46
47    // Step 3: Encode to ARM binary
48    let encoder = ArmEncoder::new_arm32();
49    let mut code = Vec::new();
50
51    for instr in &arm_instrs {
52        let encoded = encoder.encode(&instr.op)?;
53        code.extend_from_slice(&encoded);
54    }
55
56    println!("Step 3: ARM Binary Encoding");
57    println!("  Generated {} bytes of machine code", code.len());
58    print!("  Hex: ");
59    for byte in &code {
60        print!("{:02x} ", byte);
61    }
62    println!("\n");
63
64    // Step 4: Build ELF file
65    let mut elf_builder = ElfBuilder::new_arm32().with_entry(0x8000);
66
67    // Add .text section with code
68    let text_section = Section::new(".text", ElfSectionType::ProgBits)
69        .with_flags(SectionFlags::ALLOC | SectionFlags::EXEC)
70        .with_addr(0x8000)
71        .with_align(4)
72        .with_data(code.clone());
73
74    elf_builder.add_section(text_section);
75
76    // Add function symbol
77    let add_sym = Symbol::new("add")
78        .with_value(0x8000)
79        .with_size(code.len() as u32)
80        .with_binding(SymbolBinding::Global)
81        .with_type(SymbolType::Func)
82        .with_section(4);
83
84    elf_builder.add_symbol(add_sym);
85
86    // Build ELF
87    let elf_data = elf_builder.build()?;
88
89    println!("Step 4: ELF Generation");
90    println!("  ELF size: {} bytes", elf_data.len());
91    println!("  Entry point: 0x8000");
92
93    // Verify ELF header
94    assert_eq!(
95        &elf_data[0..4],
96        &[0x7f, b'E', b'L', b'F'],
97        "Invalid ELF magic"
98    );
99    println!("  ELF magic: valid");
100
101    // Step 5: Write to file
102    let output_path = "add.elf";
103    let mut file = File::create(output_path)?;
104    file.write_all(&elf_data)?;
105
106    println!("\nStep 5: Output");
107    println!("  Written to: {}", output_path);
108    println!("\n=== Compilation successful! ===");
109    println!("\nTo inspect: arm-none-eabi-objdump -d {}", output_path);
110
111    Ok(())
112}
Source

pub fn with_data(self, data: Vec<u8>) -> Self

Add data

Examples found in repository?
examples/compile_add.rs (line 72)
17fn main() -> Result<(), Box<dyn std::error::Error>> {
18    println!("=== Synth Minimal Demo: WASM -> ARM ELF ===\n");
19
20    // Step 1: Define WASM operations for add(a, b) function
21    // Equivalent to: (func (param $a i32) (param $b i32) (result i32)
22    //                  local.get $a
23    //                  local.get $b
24    //                  i32.add)
25    let wasm_ops = vec![
26        WasmOp::LocalGet(0), // Load param a
27        WasmOp::LocalGet(1), // Load param b
28        WasmOp::I32Add,      // Add them
29    ];
30
31    println!("Step 1: WASM Operations");
32    println!("  Input: add(a, b) = a + b");
33    println!("  WASM ops: {:?}\n", wasm_ops);
34
35    // Step 2: Select ARM instructions
36    let db = RuleDatabase::with_standard_rules();
37    let mut selector = InstructionSelector::new(db.rules().to_vec());
38    let arm_instrs = selector.select(&wasm_ops)?;
39
40    println!("Step 2: ARM Instruction Selection");
41    println!("  Generated {} ARM instructions:", arm_instrs.len());
42    for (i, instr) in arm_instrs.iter().enumerate() {
43        println!("    {}: {:?}", i, instr.op);
44    }
45    println!();
46
47    // Step 3: Encode to ARM binary
48    let encoder = ArmEncoder::new_arm32();
49    let mut code = Vec::new();
50
51    for instr in &arm_instrs {
52        let encoded = encoder.encode(&instr.op)?;
53        code.extend_from_slice(&encoded);
54    }
55
56    println!("Step 3: ARM Binary Encoding");
57    println!("  Generated {} bytes of machine code", code.len());
58    print!("  Hex: ");
59    for byte in &code {
60        print!("{:02x} ", byte);
61    }
62    println!("\n");
63
64    // Step 4: Build ELF file
65    let mut elf_builder = ElfBuilder::new_arm32().with_entry(0x8000);
66
67    // Add .text section with code
68    let text_section = Section::new(".text", ElfSectionType::ProgBits)
69        .with_flags(SectionFlags::ALLOC | SectionFlags::EXEC)
70        .with_addr(0x8000)
71        .with_align(4)
72        .with_data(code.clone());
73
74    elf_builder.add_section(text_section);
75
76    // Add function symbol
77    let add_sym = Symbol::new("add")
78        .with_value(0x8000)
79        .with_size(code.len() as u32)
80        .with_binding(SymbolBinding::Global)
81        .with_type(SymbolType::Func)
82        .with_section(4);
83
84    elf_builder.add_symbol(add_sym);
85
86    // Build ELF
87    let elf_data = elf_builder.build()?;
88
89    println!("Step 4: ELF Generation");
90    println!("  ELF size: {} bytes", elf_data.len());
91    println!("  Entry point: 0x8000");
92
93    // Verify ELF header
94    assert_eq!(
95        &elf_data[0..4],
96        &[0x7f, b'E', b'L', b'F'],
97        "Invalid ELF magic"
98    );
99    println!("  ELF magic: valid");
100
101    // Step 5: Write to file
102    let output_path = "add.elf";
103    let mut file = File::create(output_path)?;
104    file.write_all(&elf_data)?;
105
106    println!("\nStep 5: Output");
107    println!("  Written to: {}", output_path);
108    println!("\n=== Compilation successful! ===");
109    println!("\nTo inspect: arm-none-eabi-objdump -d {}", output_path);
110
111    Ok(())
112}
Source

pub fn with_size(self, size: u32) -> Self

Set explicit size (for NoBits sections like .bss where data is empty)

Source

pub fn size(&self) -> u32

Get the effective size of the section

Trait Implementations§

Source§

impl Clone for Section

Source§

fn clone(&self) -> Section

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Debug for Section

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.