1use core::mem;
2
3use crate::endian::{BigEndian as BE, I16, U16, U32};
4use crate::write::string::*;
5use crate::write::util::*;
6use crate::write::*;
7
8use crate::xcoff;
9
10#[derive(Default, Clone, Copy)]
11struct SectionOffsets {
12 address: u64,
13 data_offset: usize,
14 reloc_offset: usize,
15}
16
17#[derive(Default, Clone, Copy)]
18struct SymbolOffsets {
19 index: usize,
20 str_id: Option<StringId>,
21 aux_count: u8,
22 storage_class: u8,
23}
24
25impl<'a> Object<'a> {
26 pub(crate) fn xcoff_section_info(
27 &self,
28 section: StandardSection,
29 ) -> (&'static [u8], &'static [u8], SectionKind, SectionFlags) {
30 match section {
31 StandardSection::Text => (&[], &b".text"[..], SectionKind::Text, SectionFlags::None),
32 StandardSection::Data => (&[], &b".data"[..], SectionKind::Data, SectionFlags::None),
33 StandardSection::ReadOnlyData
34 | StandardSection::ReadOnlyDataWithRel
35 | StandardSection::ReadOnlyString => (
36 &[],
37 &b".rdata"[..],
38 SectionKind::ReadOnlyData,
39 SectionFlags::None,
40 ),
41 StandardSection::UninitializedData => (
42 &[],
43 &b".bss"[..],
44 SectionKind::UninitializedData,
45 SectionFlags::None,
46 ),
47 StandardSection::Tls => (&[], &b".tdata"[..], SectionKind::Tls, SectionFlags::None),
48 StandardSection::UninitializedTls => (
49 &[],
50 &b".tbss"[..],
51 SectionKind::UninitializedTls,
52 SectionFlags::None,
53 ),
54 StandardSection::TlsVariables => {
55 // Unsupported section.
56 (&[], &[], SectionKind::TlsVariables, SectionFlags::None)
57 }
58 StandardSection::Common => {
59 // Unsupported section.
60 (&[], &[], SectionKind::Common, SectionFlags::None)
61 }
62 StandardSection::GnuProperty => {
63 // Unsupported section.
64 (&[], &[], SectionKind::Note, SectionFlags::None)
65 }
66 }
67 }
68
69 pub(crate) fn xcoff_translate_relocation(&mut self, reloc: &mut Relocation) -> Result<()> {
70 let (kind, _encoding, size) = if let RelocationFlags::Generic {
71 kind,
72 encoding,
73 size,
74 } = reloc.flags
75 {
76 (kind, encoding, size)
77 } else {
78 return Ok(());
79 };
80
81 let r_rtype = match kind {
82 RelocationKind::Absolute => xcoff::R_POS,
83 RelocationKind::Relative => xcoff::R_REL,
84 RelocationKind::Got => xcoff::R_TOC,
85 _ => {
86 return Err(Error(format!("unimplemented relocation {:?}", reloc)));
87 }
88 };
89 let r_rsize = size - 1;
90 reloc.flags = RelocationFlags::Xcoff { r_rtype, r_rsize };
91 Ok(())
92 }
93
94 pub(crate) fn xcoff_adjust_addend(&mut self, relocation: &mut Relocation) -> Result<bool> {
95 let r_rtype = if let RelocationFlags::Xcoff { r_rtype, .. } = relocation.flags {
96 r_rtype
97 } else {
98 return Err(Error(format!("invalid relocation flags {:?}", relocation)));
99 };
100 if r_rtype == xcoff::R_REL {
101 relocation.addend += 4;
102 }
103 Ok(true)
104 }
105
106 pub(crate) fn xcoff_relocation_size(&self, reloc: &Relocation) -> Result<u8> {
107 let r_rsize = if let RelocationFlags::Xcoff { r_rsize, .. } = reloc.flags {
108 r_rsize
109 } else {
110 return Err(Error(format!("unexpected relocation {:?}", reloc)));
111 };
112 Ok(r_rsize + 1)
113 }
114
115 pub(crate) fn xcoff_write(&self, buffer: &mut dyn WritableBuffer) -> Result<()> {
116 let is_64 = match self.architecture.address_size().unwrap() {
117 AddressSize::U8 | AddressSize::U16 | AddressSize::U32 => false,
118 AddressSize::U64 => true,
119 };
120
121 let (hdr_size, sechdr_size, rel_size, sym_size) = if is_64 {
122 (
123 mem::size_of::<xcoff::FileHeader64>(),
124 mem::size_of::<xcoff::SectionHeader64>(),
125 mem::size_of::<xcoff::Rel64>(),
126 mem::size_of::<xcoff::Symbol64>(),
127 )
128 } else {
129 (
130 mem::size_of::<xcoff::FileHeader32>(),
131 mem::size_of::<xcoff::SectionHeader32>(),
132 mem::size_of::<xcoff::Rel32>(),
133 mem::size_of::<xcoff::Symbol32>(),
134 )
135 };
136
137 // Calculate offsets and build strtab.
138 let mut offset = 0;
139 let mut strtab = StringTable::default();
140 // We place the shared address 0 immediately after the section header table.
141 let mut address = 0;
142
143 // XCOFF file header.
144 offset += hdr_size;
145 // Section headers.
146 offset += self.sections.len() * sechdr_size;
147
148 // Calculate size of section data.
149 let mut section_offsets = vec![SectionOffsets::default(); self.sections.len()];
150 for (index, section) in self.sections.iter().enumerate() {
151 let len = section.data.len();
152 let sectype = section.kind;
153 // Section address should be 0 for all sections except the .text, .data, and .bss sections.
154 if sectype == SectionKind::Data
155 || sectype == SectionKind::Text
156 || sectype == SectionKind::UninitializedData
157 {
158 section_offsets[index].address = address as u64;
159 address += len;
160 address = align(address, 4);
161 } else {
162 section_offsets[index].address = 0;
163 }
164 if len != 0 {
165 // Set the default section alignment as 4.
166 offset = align(offset, 4);
167 section_offsets[index].data_offset = offset;
168 offset += len;
169 } else {
170 section_offsets[index].data_offset = 0;
171 }
172 }
173
174 // Calculate size of relocations.
175 for (index, section) in self.sections.iter().enumerate() {
176 let count = section.relocations.len();
177 if count != 0 {
178 section_offsets[index].reloc_offset = offset;
179 offset += count * rel_size;
180 } else {
181 section_offsets[index].reloc_offset = 0;
182 }
183 }
184
185 // Calculate size of symbols.
186 let mut file_str_id = None;
187 let mut symbol_offsets = vec![SymbolOffsets::default(); self.symbols.len()];
188 let mut symtab_count = 0;
189 for (index, symbol) in self.symbols.iter().enumerate() {
190 symbol_offsets[index].index = symtab_count;
191 symtab_count += 1;
192
193 let storage_class = if let SymbolFlags::Xcoff { n_sclass, .. } = symbol.flags {
194 n_sclass
195 } else {
196 match symbol.kind {
197 SymbolKind::File => xcoff::C_FILE,
198 SymbolKind::Text | SymbolKind::Data | SymbolKind::Tls => {
199 if symbol.is_local() {
200 xcoff::C_STAT
201 } else if symbol.weak {
202 xcoff::C_WEAKEXT
203 } else {
204 xcoff::C_EXT
205 }
206 }
207 SymbolKind::Section | SymbolKind::Label | SymbolKind::Unknown => {
208 return Err(Error(format!(
209 "unimplemented symbol `{}` kind {:?}",
210 symbol.name().unwrap_or(""),
211 symbol.kind
212 )));
213 }
214 }
215 };
216 symbol_offsets[index].storage_class = storage_class;
217
218 if storage_class == xcoff::C_FILE {
219 if is_64 && file_str_id.is_none() {
220 file_str_id = Some(strtab.add(b".file"));
221 }
222 if symbol.name.len() > 8 {
223 symbol_offsets[index].str_id = Some(strtab.add(&symbol.name));
224 }
225 } else if is_64 || symbol.name.len() > 8 {
226 symbol_offsets[index].str_id = Some(strtab.add(&symbol.name));
227 }
228
229 symbol_offsets[index].aux_count = 0;
230 match storage_class {
231 xcoff::C_FILE => {
232 symbol_offsets[index].aux_count = 1;
233 symtab_count += 1;
234 }
235 xcoff::C_EXT | xcoff::C_WEAKEXT | xcoff::C_HIDEXT => {
236 symbol_offsets[index].aux_count = 1;
237 symtab_count += 1;
238 }
239 // TODO: support auxiliary entry for other types of symbol.
240 _ => {}
241 }
242 }
243 let symtab_offset = offset;
244 let symtab_len = symtab_count * sym_size;
245 offset += symtab_len;
246
247 // Calculate size of strtab.
248 let strtab_offset = offset;
249 let mut strtab_data = Vec::new();
250 // First 4 bytes of strtab are the length.
251 strtab.write(4, &mut strtab_data);
252 let strtab_len = strtab_data.len() + 4;
253 offset += strtab_len;
254
255 // Start writing.
256 buffer
257 .reserve(offset)
258 .map_err(|_| Error(String::from("Cannot allocate buffer")))?;
259
260 // Write file header.
261 if is_64 {
262 let header = xcoff::FileHeader64 {
263 f_magic: U16::new(BE, xcoff::MAGIC_64),
264 f_nscns: U16::new(BE, self.sections.len() as u16),
265 f_timdat: U32::new(BE, 0),
266 f_symptr: U64::new(BE, symtab_offset as u64),
267 f_nsyms: U32::new(BE, symtab_count as u32),
268 f_opthdr: U16::new(BE, 0),
269 f_flags: match self.flags {
270 FileFlags::Xcoff { f_flags } => U16::new(BE, f_flags),
271 _ => U16::default(),
272 },
273 };
274 buffer.write(&header);
275 } else {
276 let header = xcoff::FileHeader32 {
277 f_magic: U16::new(BE, xcoff::MAGIC_32),
278 f_nscns: U16::new(BE, self.sections.len() as u16),
279 f_timdat: U32::new(BE, 0),
280 f_symptr: U32::new(BE, symtab_offset as u32),
281 f_nsyms: U32::new(BE, symtab_count as u32),
282 f_opthdr: U16::new(BE, 0),
283 f_flags: match self.flags {
284 FileFlags::Xcoff { f_flags } => U16::new(BE, f_flags),
285 _ => U16::default(),
286 },
287 };
288 buffer.write(&header);
289 }
290
291 // Write section headers.
292 for (index, section) in self.sections.iter().enumerate() {
293 let mut sectname = [0; 8];
294 sectname
295 .get_mut(..section.name.len())
296 .ok_or_else(|| {
297 Error(format!(
298 "section name `{}` is too long",
299 section.name().unwrap_or(""),
300 ))
301 })?
302 .copy_from_slice(&section.name);
303 let flags = if let SectionFlags::Xcoff { s_flags } = section.flags {
304 s_flags
305 } else {
306 match section.kind {
307 SectionKind::Text
308 | SectionKind::ReadOnlyData
309 | SectionKind::ReadOnlyString
310 | SectionKind::ReadOnlyDataWithRel => xcoff::STYP_TEXT,
311 SectionKind::Data => xcoff::STYP_DATA,
312 SectionKind::UninitializedData => xcoff::STYP_BSS,
313 SectionKind::Tls => xcoff::STYP_TDATA,
314 SectionKind::UninitializedTls => xcoff::STYP_TBSS,
315 SectionKind::OtherString => xcoff::STYP_INFO,
316 SectionKind::Debug | SectionKind::DebugString => xcoff::STYP_DEBUG,
317 SectionKind::Other | SectionKind::Metadata => 0,
318 SectionKind::Note
319 | SectionKind::Linker
320 | SectionKind::Common
321 | SectionKind::Unknown
322 | SectionKind::TlsVariables
323 | SectionKind::Elf(_) => {
324 return Err(Error(format!(
325 "unimplemented section `{}` kind {:?}",
326 section.name().unwrap_or(""),
327 section.kind
328 )));
329 }
330 }
331 .into()
332 };
333 if is_64 {
334 let section_header = xcoff::SectionHeader64 {
335 s_name: sectname,
336 s_paddr: U64::new(BE, section_offsets[index].address),
337 // This field has the same value as the s_paddr field.
338 s_vaddr: U64::new(BE, section_offsets[index].address),
339 s_size: U64::new(BE, section.data.len() as u64),
340 s_scnptr: U64::new(BE, section_offsets[index].data_offset as u64),
341 s_relptr: U64::new(BE, section_offsets[index].reloc_offset as u64),
342 s_lnnoptr: U64::new(BE, 0),
343 s_nreloc: U32::new(BE, section.relocations.len() as u32),
344 s_nlnno: U32::new(BE, 0),
345 s_flags: U32::new(BE, flags),
346 s_reserve: U32::new(BE, 0),
347 };
348 buffer.write(&section_header);
349 } else {
350 let section_header = xcoff::SectionHeader32 {
351 s_name: sectname,
352 s_paddr: U32::new(BE, section_offsets[index].address as u32),
353 // This field has the same value as the s_paddr field.
354 s_vaddr: U32::new(BE, section_offsets[index].address as u32),
355 s_size: U32::new(BE, section.data.len() as u32),
356 s_scnptr: U32::new(BE, section_offsets[index].data_offset as u32),
357 s_relptr: U32::new(BE, section_offsets[index].reloc_offset as u32),
358 s_lnnoptr: U32::new(BE, 0),
359 // TODO: If more than 65,534 relocation entries are required, the field
360 // value will be 65535, and an STYP_OVRFLO section header will contain
361 // the actual count of relocation entries in the s_paddr field.
362 s_nreloc: U16::new(BE, section.relocations.len() as u16),
363 s_nlnno: U16::new(BE, 0),
364 s_flags: U32::new(BE, flags),
365 };
366 buffer.write(&section_header);
367 }
368 }
369
370 // Write section data.
371 for (index, section) in self.sections.iter().enumerate() {
372 let len = section.data.len();
373 if len != 0 {
374 write_align(buffer, 4);
375 debug_assert_eq!(section_offsets[index].data_offset, buffer.len());
376 buffer.write_bytes(&section.data);
377 }
378 }
379
380 // Write relocations.
381 for (index, section) in self.sections.iter().enumerate() {
382 if !section.relocations.is_empty() {
383 debug_assert_eq!(section_offsets[index].reloc_offset, buffer.len());
384 for reloc in &section.relocations {
385 let (r_rtype, r_rsize) =
386 if let RelocationFlags::Xcoff { r_rtype, r_rsize } = reloc.flags {
387 (r_rtype, r_rsize)
388 } else {
389 return Err(Error("invalid relocation flags".into()));
390 };
391 if is_64 {
392 let xcoff_rel = xcoff::Rel64 {
393 r_vaddr: U64::new(BE, reloc.offset),
394 r_symndx: U32::new(BE, symbol_offsets[reloc.symbol.0].index as u32),
395 r_rsize,
396 r_rtype,
397 };
398 buffer.write(&xcoff_rel);
399 } else {
400 let xcoff_rel = xcoff::Rel32 {
401 r_vaddr: U32::new(BE, reloc.offset as u32),
402 r_symndx: U32::new(BE, symbol_offsets[reloc.symbol.0].index as u32),
403 r_rsize,
404 r_rtype,
405 };
406 buffer.write(&xcoff_rel);
407 }
408 }
409 }
410 }
411
412 // Write symbols.
413 debug_assert_eq!(symtab_offset, buffer.len());
414 for (index, symbol) in self.symbols.iter().enumerate() {
415 let (n_value, section_kind) = if let SymbolSection::Section(id) = symbol.section {
416 (
417 section_offsets[id.0].address + symbol.value,
418 self.sections[id.0].kind,
419 )
420 } else {
421 (symbol.value, SectionKind::Unknown)
422 };
423 let n_scnum = match symbol.section {
424 SymbolSection::None => {
425 debug_assert_eq!(symbol.kind, SymbolKind::File);
426 xcoff::N_DEBUG
427 }
428 SymbolSection::Undefined | SymbolSection::Common => xcoff::N_UNDEF,
429 SymbolSection::Absolute => xcoff::N_ABS,
430 SymbolSection::Section(id) => id.0 as i16 + 1,
431 };
432 let n_sclass = symbol_offsets[index].storage_class;
433 let n_type = if (symbol.scope == SymbolScope::Linkage)
434 && (n_sclass == xcoff::C_EXT
435 || n_sclass == xcoff::C_WEAKEXT
436 || n_sclass == xcoff::C_HIDEXT)
437 {
438 xcoff::SYM_V_HIDDEN
439 } else {
440 0
441 };
442 let n_numaux = symbol_offsets[index].aux_count;
443 if is_64 {
444 let str_id = if n_sclass == xcoff::C_FILE {
445 file_str_id.unwrap()
446 } else {
447 symbol_offsets[index].str_id.unwrap()
448 };
449 let xcoff_sym = xcoff::Symbol64 {
450 n_value: U64::new(BE, n_value),
451 n_offset: U32::new(BE, strtab.get_offset(str_id) as u32),
452 n_scnum: I16::new(BE, n_scnum),
453 n_type: U16::new(BE, n_type),
454 n_sclass,
455 n_numaux,
456 };
457 buffer.write(&xcoff_sym);
458 } else {
459 let mut sym_name = [0; 8];
460 if n_sclass == xcoff::C_FILE {
461 sym_name[..5].copy_from_slice(b".file");
462 } else if symbol.name.len() <= 8 {
463 sym_name[..symbol.name.len()].copy_from_slice(&symbol.name[..]);
464 } else {
465 let str_offset = strtab.get_offset(symbol_offsets[index].str_id.unwrap());
466 sym_name[4..8].copy_from_slice(&u32::to_be_bytes(str_offset as u32));
467 }
468 let xcoff_sym = xcoff::Symbol32 {
469 n_name: sym_name,
470 n_value: U32::new(BE, n_value as u32),
471 n_scnum: I16::new(BE, n_scnum),
472 n_type: U16::new(BE, n_type),
473 n_sclass,
474 n_numaux,
475 };
476 buffer.write(&xcoff_sym);
477 }
478 // Generate auxiliary entries.
479 if n_sclass == xcoff::C_FILE {
480 debug_assert_eq!(n_numaux, 1);
481 let mut x_fname = [0; 8];
482 if symbol.name.len() <= 8 {
483 x_fname[..symbol.name.len()].copy_from_slice(&symbol.name[..]);
484 } else {
485 let str_offset = strtab.get_offset(symbol_offsets[index].str_id.unwrap());
486 x_fname[4..8].copy_from_slice(&u32::to_be_bytes(str_offset as u32));
487 }
488 if is_64 {
489 let file_aux = xcoff::FileAux64 {
490 x_fname,
491 x_fpad: Default::default(),
492 x_ftype: xcoff::XFT_FN,
493 x_freserve: Default::default(),
494 x_auxtype: xcoff::AUX_FILE,
495 };
496 buffer.write(&file_aux);
497 } else {
498 let file_aux = xcoff::FileAux32 {
499 x_fname,
500 x_fpad: Default::default(),
501 x_ftype: xcoff::XFT_FN,
502 x_freserve: Default::default(),
503 };
504 buffer.write(&file_aux);
505 }
506 } else if n_sclass == xcoff::C_EXT
507 || n_sclass == xcoff::C_WEAKEXT
508 || n_sclass == xcoff::C_HIDEXT
509 {
510 debug_assert_eq!(n_numaux, 1);
511 let (x_smtyp, x_smclas) = if let SymbolFlags::Xcoff {
512 x_smtyp, x_smclas, ..
513 } = symbol.flags
514 {
515 (x_smtyp, x_smclas)
516 } else {
517 match symbol.kind {
518 SymbolKind::Text => (xcoff::XTY_SD, xcoff::XMC_PR),
519 SymbolKind::Data => {
520 if section_kind == SectionKind::UninitializedData {
521 (xcoff::XTY_CM, xcoff::XMC_BS)
522 } else if section_kind == SectionKind::ReadOnlyData {
523 (xcoff::XTY_SD, xcoff::XMC_RO)
524 } else {
525 (xcoff::XTY_SD, xcoff::XMC_RW)
526 }
527 }
528 SymbolKind::Tls => {
529 if section_kind == SectionKind::UninitializedTls {
530 (xcoff::XTY_CM, xcoff::XMC_UL)
531 } else {
532 (xcoff::XTY_SD, xcoff::XMC_TL)
533 }
534 }
535 _ => {
536 return Err(Error(format!(
537 "unimplemented symbol `{}` kind {:?}",
538 symbol.name().unwrap_or(""),
539 symbol.kind
540 )));
541 }
542 }
543 };
544 let scnlen = if let SymbolFlags::Xcoff {
545 containing_csect: Some(containing_csect),
546 ..
547 } = symbol.flags
548 {
549 symbol_offsets[containing_csect.0].index as u64
550 } else {
551 symbol.size
552 };
553 if is_64 {
554 let csect_aux = xcoff::CsectAux64 {
555 x_scnlen_lo: U32::new(BE, (scnlen & 0xFFFFFFFF) as u32),
556 x_scnlen_hi: U32::new(BE, ((scnlen >> 32) & 0xFFFFFFFF) as u32),
557 x_parmhash: U32::new(BE, 0),
558 x_snhash: U16::new(BE, 0),
559 x_smtyp,
560 x_smclas,
561 pad: 0,
562 x_auxtype: xcoff::AUX_CSECT,
563 };
564 buffer.write(&csect_aux);
565 } else {
566 let csect_aux = xcoff::CsectAux32 {
567 x_scnlen: U32::new(BE, scnlen as u32),
568 x_parmhash: U32::new(BE, 0),
569 x_snhash: U16::new(BE, 0),
570 x_smtyp,
571 x_smclas,
572 x_stab: U32::new(BE, 0),
573 x_snstab: U16::new(BE, 0),
574 };
575 buffer.write(&csect_aux);
576 }
577 }
578 }
579
580 // Write string table.
581 debug_assert_eq!(strtab_offset, buffer.len());
582 buffer.write_bytes(&u32::to_be_bytes(strtab_len as u32));
583 buffer.write_bytes(&strtab_data);
584
585 debug_assert_eq!(offset, buffer.len());
586 Ok(())
587 }
588}
589