1 #![cfg(all(feature = "read", feature = "write"))]
2 
3 use object::read::{Object, ObjectSection, ObjectSymbol};
4 use object::{read, write};
5 use object::{
6     Architecture, BinaryFormat, Endianness, SectionKind, SymbolFlags, SymbolKind, SymbolScope,
7 };
8 
9 #[test]
coff_x86_64_bss()10 fn coff_x86_64_bss() {
11     let mut object =
12         write::Object::new(BinaryFormat::Coff, Architecture::X86_64, Endianness::Little);
13 
14     let section = object.section_id(write::StandardSection::UninitializedData);
15 
16     let symbol = object.add_symbol(write::Symbol {
17         name: b"v1".to_vec(),
18         value: 0,
19         size: 0,
20         kind: SymbolKind::Data,
21         scope: SymbolScope::Linkage,
22         weak: false,
23         section: write::SymbolSection::Undefined,
24         flags: SymbolFlags::None,
25     });
26     object.add_symbol_bss(symbol, section, 18, 4);
27 
28     let symbol = object.add_symbol(write::Symbol {
29         name: b"v2".to_vec(),
30         value: 0,
31         size: 0,
32         kind: SymbolKind::Data,
33         scope: SymbolScope::Linkage,
34         weak: false,
35         section: write::SymbolSection::Undefined,
36         flags: SymbolFlags::None,
37     });
38     object.add_symbol_bss(symbol, section, 34, 8);
39 
40     let bytes = object.write().unwrap();
41 
42     //std::fs::write(&"bss.o", &bytes).unwrap();
43 
44     let object = read::File::parse(&bytes).unwrap();
45     assert_eq!(object.format(), BinaryFormat::Coff);
46     assert_eq!(object.architecture(), Architecture::X86_64);
47 
48     let mut sections = object.sections();
49 
50     let bss = sections.next().unwrap();
51     println!("{:?}", bss);
52     let bss_index = bss.index();
53     assert_eq!(bss.name(), Ok(".bss"));
54     assert_eq!(bss.kind(), SectionKind::UninitializedData);
55     assert_eq!(bss.size(), 58);
56     assert_eq!(bss.data(), Ok(&[][..]));
57 
58     let section = sections.next();
59     assert!(
60         section.is_none(),
61         format!("unexpected section {:?}", section)
62     );
63 
64     let mut symbols = object.symbols();
65 
66     let symbol = symbols.next().unwrap();
67     println!("{:?}", symbol);
68     assert_eq!(symbol.name(), Ok("v1"));
69     assert_eq!(symbol.kind(), SymbolKind::Data);
70     assert_eq!(symbol.section_index(), Some(bss_index));
71     assert_eq!(symbol.scope(), SymbolScope::Linkage);
72     assert_eq!(symbol.is_weak(), false);
73     assert_eq!(symbol.is_undefined(), false);
74     assert_eq!(symbol.address(), 0);
75 
76     let symbol = symbols.next().unwrap();
77     println!("{:?}", symbol);
78     assert_eq!(symbol.name(), Ok("v2"));
79     assert_eq!(symbol.kind(), SymbolKind::Data);
80     assert_eq!(symbol.section_index(), Some(bss_index));
81     assert_eq!(symbol.scope(), SymbolScope::Linkage);
82     assert_eq!(symbol.is_weak(), false);
83     assert_eq!(symbol.is_undefined(), false);
84     assert_eq!(symbol.address(), 24);
85 
86     let symbol = symbols.next();
87     assert!(symbol.is_none(), format!("unexpected symbol {:?}", symbol));
88 }
89 
90 #[test]
elf_x86_64_bss()91 fn elf_x86_64_bss() {
92     let mut object =
93         write::Object::new(BinaryFormat::Elf, Architecture::X86_64, Endianness::Little);
94 
95     let section = object.section_id(write::StandardSection::UninitializedData);
96 
97     let symbol = object.add_symbol(write::Symbol {
98         name: b"v1".to_vec(),
99         value: 0,
100         size: 0,
101         kind: SymbolKind::Data,
102         scope: SymbolScope::Linkage,
103         weak: false,
104         section: write::SymbolSection::Undefined,
105         flags: SymbolFlags::None,
106     });
107     object.add_symbol_bss(symbol, section, 18, 4);
108 
109     let symbol = object.add_symbol(write::Symbol {
110         name: b"v2".to_vec(),
111         value: 0,
112         size: 0,
113         kind: SymbolKind::Data,
114         scope: SymbolScope::Linkage,
115         weak: false,
116         section: write::SymbolSection::Undefined,
117         flags: SymbolFlags::None,
118     });
119     object.add_symbol_bss(symbol, section, 34, 8);
120 
121     let bytes = object.write().unwrap();
122 
123     //std::fs::write(&"bss.o", &bytes).unwrap();
124 
125     let object = read::File::parse(&bytes).unwrap();
126     assert_eq!(object.format(), BinaryFormat::Elf);
127     assert_eq!(object.architecture(), Architecture::X86_64);
128 
129     let mut sections = object.sections();
130 
131     let section = sections.next().unwrap();
132     println!("{:?}", section);
133     assert_eq!(section.name(), Ok(""));
134     assert_eq!(section.kind(), SectionKind::Metadata);
135     assert_eq!(section.address(), 0);
136     assert_eq!(section.size(), 0);
137 
138     let bss = sections.next().unwrap();
139     println!("{:?}", bss);
140     let bss_index = bss.index();
141     assert_eq!(bss.name(), Ok(".bss"));
142     assert_eq!(bss.kind(), SectionKind::UninitializedData);
143     assert_eq!(bss.size(), 58);
144     assert_eq!(bss.data(), Ok(&[][..]));
145 
146     let mut symbols = object.symbols();
147 
148     let symbol = symbols.next().unwrap();
149     println!("{:?}", symbol);
150     assert_eq!(symbol.name(), Ok(""));
151 
152     let symbol = symbols.next().unwrap();
153     println!("{:?}", symbol);
154     assert_eq!(symbol.name(), Ok("v1"));
155     assert_eq!(symbol.kind(), SymbolKind::Data);
156     assert_eq!(symbol.section_index(), Some(bss_index));
157     assert_eq!(symbol.scope(), SymbolScope::Linkage);
158     assert_eq!(symbol.is_weak(), false);
159     assert_eq!(symbol.is_undefined(), false);
160     assert_eq!(symbol.address(), 0);
161     assert_eq!(symbol.size(), 18);
162 
163     let symbol = symbols.next().unwrap();
164     println!("{:?}", symbol);
165     assert_eq!(symbol.name(), Ok("v2"));
166     assert_eq!(symbol.kind(), SymbolKind::Data);
167     assert_eq!(symbol.section_index(), Some(bss_index));
168     assert_eq!(symbol.scope(), SymbolScope::Linkage);
169     assert_eq!(symbol.is_weak(), false);
170     assert_eq!(symbol.is_undefined(), false);
171     assert_eq!(symbol.address(), 24);
172     assert_eq!(symbol.size(), 34);
173 
174     let symbol = symbols.next();
175     assert!(symbol.is_none(), format!("unexpected symbol {:?}", symbol));
176 }
177 
178 #[test]
macho_x86_64_bss()179 fn macho_x86_64_bss() {
180     let mut object = write::Object::new(
181         BinaryFormat::MachO,
182         Architecture::X86_64,
183         Endianness::Little,
184     );
185 
186     let section = object.section_id(write::StandardSection::UninitializedData);
187 
188     let symbol = object.add_symbol(write::Symbol {
189         name: b"v1".to_vec(),
190         value: 0,
191         size: 0,
192         kind: SymbolKind::Data,
193         scope: SymbolScope::Linkage,
194         weak: false,
195         section: write::SymbolSection::Undefined,
196         flags: SymbolFlags::None,
197     });
198     object.add_symbol_bss(symbol, section, 18, 4);
199 
200     let symbol = object.add_symbol(write::Symbol {
201         name: b"v2".to_vec(),
202         value: 0,
203         size: 0,
204         kind: SymbolKind::Data,
205         scope: SymbolScope::Linkage,
206         weak: false,
207         section: write::SymbolSection::Undefined,
208         flags: SymbolFlags::None,
209     });
210     object.add_symbol_bss(symbol, section, 34, 8);
211 
212     let bytes = object.write().unwrap();
213 
214     //std::fs::write(&"bss.o", &bytes).unwrap();
215 
216     let object = read::File::parse(&bytes).unwrap();
217     assert_eq!(object.format(), BinaryFormat::MachO);
218     assert_eq!(object.architecture(), Architecture::X86_64);
219 
220     let mut sections = object.sections();
221 
222     let bss = sections.next().unwrap();
223     println!("{:?}", bss);
224     let bss_index = bss.index();
225     assert_eq!(bss.name(), Ok("__bss"));
226     assert_eq!(bss.segment_name(), Ok(Some("__DATA")));
227     assert_eq!(bss.kind(), SectionKind::UninitializedData);
228     assert_eq!(bss.size(), 58);
229     assert_eq!(bss.data(), Ok(&[][..]));
230 
231     let section = sections.next();
232     assert!(
233         section.is_none(),
234         format!("unexpected section {:?}", section)
235     );
236 
237     let mut symbols = object.symbols();
238 
239     let symbol = symbols.next().unwrap();
240     println!("{:?}", symbol);
241     assert_eq!(symbol.name(), Ok("_v1"));
242     assert_eq!(symbol.kind(), SymbolKind::Data);
243     assert_eq!(symbol.section_index(), Some(bss_index));
244     assert_eq!(symbol.scope(), SymbolScope::Linkage);
245     assert_eq!(symbol.is_weak(), false);
246     assert_eq!(symbol.is_undefined(), false);
247     assert_eq!(symbol.address(), 0);
248 
249     let symbol = symbols.next().unwrap();
250     println!("{:?}", symbol);
251     assert_eq!(symbol.name(), Ok("_v2"));
252     assert_eq!(symbol.kind(), SymbolKind::Data);
253     assert_eq!(symbol.section_index(), Some(bss_index));
254     assert_eq!(symbol.scope(), SymbolScope::Linkage);
255     assert_eq!(symbol.is_weak(), false);
256     assert_eq!(symbol.is_undefined(), false);
257     assert_eq!(symbol.address(), 24);
258 
259     let symbol = symbols.next();
260     assert!(symbol.is_none(), format!("unexpected symbol {:?}", symbol));
261 }
262