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