Struct Symbol

Source

pub struct Symbol {
    pub name: String,
    pub value: u32,
    pub size: u32,
    pub binding: SymbolBinding,
    pub symbol_type: SymbolType,
    pub section: u16,
}

Expand description

ELF symbol

Fields§

§name: String

Symbol name

§value: u32

Value/address

§size: u32

Size

§binding: SymbolBinding

Binding

§symbol_type: SymbolType

Type

§section: u16

Section index

Implementations§

Source §

impl Symbol

Source

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

Create a new symbol

Examples found in repository ?

examples/compile_add.rs (line 77)

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_value(self, value: u32) -> Self

Set value

Examples found in repository ?

examples/compile_add.rs (line 78)

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 size

Examples found in repository ?

examples/compile_add.rs (line 79)

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_binding(self, binding: SymbolBinding) -> Self

Set binding

Examples found in repository ?

examples/compile_add.rs (line 80)

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_type(self, symbol_type: SymbolType) -> Self

Set type

Examples found in repository ?

examples/compile_add.rs (line 81)

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_section(self, section: u16) -> Self

Set section

Examples found in repository ?

examples/compile_add.rs (line 82)

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}