blob: f41f47a718cbb9f353cfc19c8d4b946346f7e7fc [file] [log] [blame]
//===-- lib/MC/XCOFFObjectWriter.cpp - XCOFF file writer ------------------===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// This file implements XCOFF object file writer information.
#include "llvm/BinaryFormat/XCOFF.h"
#include "llvm/MC/MCAsmBackend.h"
#include "llvm/MC/MCAsmLayout.h"
#include "llvm/MC/MCAssembler.h"
#include "llvm/MC/MCFixup.h"
#include "llvm/MC/MCFixupKindInfo.h"
#include "llvm/MC/MCObjectWriter.h"
#include "llvm/MC/MCSectionXCOFF.h"
#include "llvm/MC/MCSymbolXCOFF.h"
#include "llvm/MC/MCValue.h"
#include "llvm/MC/MCXCOFFObjectWriter.h"
#include "llvm/MC/StringTableBuilder.h"
#include "llvm/Support/EndianStream.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/MathExtras.h"
#include <deque>
using namespace llvm;
// An XCOFF object file has a limited set of predefined sections. The most
// important ones for us (right now) are:
// .text --> contains program code and read-only data.
// .data --> contains initialized data, function descriptors, and the TOC.
// .bss --> contains uninitialized data.
// Each of these sections is composed of 'Control Sections'. A Control Section
// is more commonly referred to as a csect. A csect is an indivisible unit of
// code or data, and acts as a container for symbols. A csect is mapped
// into a section based on its storage-mapping class, with the exception of
// XMC_RW which gets mapped to either .data or .bss based on whether it's
// explicitly initialized or not.
// We don't represent the sections in the MC layer as there is nothing
// interesting about them at at that level: they carry information that is
// only relevant to the ObjectWriter, so we materialize them in this class.
namespace {
constexpr unsigned DefaultSectionAlign = 4;
constexpr int16_t MaxSectionIndex = INT16_MAX;
// Packs the csect's alignment and type into a byte.
uint8_t getEncodedType(const MCSectionXCOFF *);
struct XCOFFRelocation {
uint32_t SymbolTableIndex;
uint32_t FixupOffsetInCsect;
uint8_t SignAndSize;
uint8_t Type;
// Wrapper around an MCSymbolXCOFF.
struct Symbol {
const MCSymbolXCOFF *const MCSym;
uint32_t SymbolTableIndex;
XCOFF::StorageClass getStorageClass() const {
return MCSym->getStorageClass();
StringRef getSymbolTableName() const { return MCSym->getSymbolTableName(); }
Symbol(const MCSymbolXCOFF *MCSym) : MCSym(MCSym), SymbolTableIndex(-1) {}
// Wrapper for an MCSectionXCOFF.
struct ControlSection {
const MCSectionXCOFF *const MCCsect;
uint32_t SymbolTableIndex;
uint32_t Address;
uint32_t Size;
SmallVector<Symbol, 1> Syms;
SmallVector<XCOFFRelocation, 1> Relocations;
StringRef getSymbolTableName() const { return MCCsect->getSymbolTableName(); }
ControlSection(const MCSectionXCOFF *MCSec)
: MCCsect(MCSec), SymbolTableIndex(-1), Address(-1), Size(0) {}
// Type to be used for a container representing a set of csects with
// (approximately) the same storage mapping class. For example all the csects
// with a storage mapping class of `xmc_pr` will get placed into the same
// container.
using CsectGroup = std::deque<ControlSection>;
using CsectGroups = std::deque<CsectGroup *>;
// Represents the data related to a section excluding the csects that make up
// the raw data of the section. The csects are stored separately as not all
// sections contain csects, and some sections contain csects which are better
// stored separately, e.g. the .data section containing read-write, descriptor,
// TOCBase and TOC-entry csects.
struct Section {
char Name[XCOFF::NameSize];
// The physical/virtual address of the section. For an object file
// these values are equivalent.
uint32_t Address;
uint32_t Size;
uint32_t FileOffsetToData;
uint32_t FileOffsetToRelocations;
uint32_t RelocationCount;
int32_t Flags;
int16_t Index;
// Virtual sections do not need storage allocated in the object file.
const bool IsVirtual;
// XCOFF has special section numbers for symbols:
// -2 Specifies N_DEBUG, a special symbolic debugging symbol.
// -1 Specifies N_ABS, an absolute symbol. The symbol has a value but is not
// relocatable.
// 0 Specifies N_UNDEF, an undefined external symbol.
// Therefore, we choose -3 (N_DEBUG - 1) to represent a section index that
// hasn't been initialized.
static constexpr int16_t UninitializedIndex =
XCOFF::ReservedSectionNum::N_DEBUG - 1;
CsectGroups Groups;
void reset() {
Address = 0;
Size = 0;
FileOffsetToData = 0;
FileOffsetToRelocations = 0;
RelocationCount = 0;
Index = UninitializedIndex;
// Clear any csects we have stored.
for (auto *Group : Groups)
Section(StringRef N, XCOFF::SectionTypeFlags Flags, bool IsVirtual,
CsectGroups Groups)
: Name(), Address(0), Size(0), FileOffsetToData(0),
FileOffsetToRelocations(0), RelocationCount(0), Flags(Flags),
Index(UninitializedIndex), IsVirtual(IsVirtual), Groups(Groups) {
assert(N.size() <= XCOFF::NameSize && "section name too long");
memcpy(Name,, N.size());
class XCOFFObjectWriter : public MCObjectWriter {
uint32_t SymbolTableEntryCount = 0;
uint32_t SymbolTableOffset = 0;
uint16_t SectionCount = 0;
uint32_t RelocationEntryOffset = 0;
support::endian::Writer W;
std::unique_ptr<MCXCOFFObjectTargetWriter> TargetObjectWriter;
StringTableBuilder Strings;
// Maps the MCSection representation to its corresponding ControlSection
// wrapper. Needed for finding the ControlSection to insert an MCSymbol into
// from its containing MCSectionXCOFF.
DenseMap<const MCSectionXCOFF *, ControlSection *> SectionMap;
// Maps the MCSymbol representation to its corrresponding symbol table index.
// Needed for relocation.
DenseMap<const MCSymbol *, uint32_t> SymbolIndexMap;
// CsectGroups. These store the csects which make up different parts of
// the sections. Should have one for each set of csects that get mapped into
// the same section and get handled in a 'similar' way.
CsectGroup UndefinedCsects;
CsectGroup ProgramCodeCsects;
CsectGroup ReadOnlyCsects;
CsectGroup DataCsects;
CsectGroup FuncDSCsects;
CsectGroup TOCCsects;
CsectGroup BSSCsects;
CsectGroup TDataCsects;
CsectGroup TBSSCsects;
// The Predefined sections.
Section Text;
Section Data;
Section BSS;
Section TData;
Section TBSS;
// All the XCOFF sections, in the order they will appear in the section header
// table.
std::array<Section *const, 5> Sections{{&Text, &Data, &BSS, &TData, &TBSS}};
CsectGroup &getCsectGroup(const MCSectionXCOFF *MCSec);
virtual void reset() override;
void executePostLayoutBinding(MCAssembler &, const MCAsmLayout &) override;
void recordRelocation(MCAssembler &, const MCAsmLayout &, const MCFragment *,
const MCFixup &, MCValue, uint64_t &) override;
uint64_t writeObject(MCAssembler &, const MCAsmLayout &) override;
static bool nameShouldBeInStringTable(const StringRef &);
void writeSymbolName(const StringRef &);
void writeSymbolTableEntryForCsectMemberLabel(const Symbol &,
const ControlSection &, int16_t,
void writeSymbolTableEntryForControlSection(const ControlSection &, int16_t,
void writeFileHeader();
void writeSectionHeaderTable();
void writeSections(const MCAssembler &Asm, const MCAsmLayout &Layout);
void writeSymbolTable(const MCAsmLayout &Layout);
void writeRelocations();
void writeRelocation(XCOFFRelocation Reloc, const ControlSection &CSection);
// Called after all the csects and symbols have been processed by
// `executePostLayoutBinding`, this function handles building up the majority
// of the structures in the object file representation. Namely:
// *) Calculates physical/virtual addresses, raw-pointer offsets, and section
// sizes.
// *) Assigns symbol table indices.
// *) Builds up the section header table by adding any non-empty sections to
// `Sections`.
void assignAddressesAndIndices(const MCAsmLayout &);
void finalizeSectionInfo();
needsAuxiliaryHeader() const { /* TODO aux header support not implemented. */
return false;
// Returns the size of the auxiliary header to be written to the object file.
size_t auxiliaryHeaderSize() const {
assert(!needsAuxiliaryHeader() &&
"Auxiliary header support not implemented.");
return 0;
XCOFFObjectWriter(std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW,
raw_pwrite_stream &OS);
std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW, raw_pwrite_stream &OS)
: W(OS, support::big), TargetObjectWriter(std::move(MOTW)),
Text(".text", XCOFF::STYP_TEXT, /* IsVirtual */ false,
CsectGroups{&ProgramCodeCsects, &ReadOnlyCsects}),
Data(".data", XCOFF::STYP_DATA, /* IsVirtual */ false,
CsectGroups{&DataCsects, &FuncDSCsects, &TOCCsects}),
BSS(".bss", XCOFF::STYP_BSS, /* IsVirtual */ true,
TData(".tdata", XCOFF::STYP_TDATA, /* IsVirtual */ false,
TBSS(".tbss", XCOFF::STYP_TBSS, /* IsVirtual */ true,
CsectGroups{&TBSSCsects}) {}
void XCOFFObjectWriter::reset() {
// Clear the mappings we created.
// Reset any sections we have written to, and empty the section header table.
for (auto *Sec : Sections)
// Reset states in XCOFFObjectWriter.
SymbolTableEntryCount = 0;
SymbolTableOffset = 0;
SectionCount = 0;
RelocationEntryOffset = 0;
CsectGroup &XCOFFObjectWriter::getCsectGroup(const MCSectionXCOFF *MCSec) {
switch (MCSec->getMappingClass()) {
assert(XCOFF::XTY_SD == MCSec->getCSectType() &&
"Only an initialized csect can contain program code.");
return ProgramCodeCsects;
assert(XCOFF::XTY_SD == MCSec->getCSectType() &&
"Only an initialized csect can contain read only data.");
return ReadOnlyCsects;
if (XCOFF::XTY_CM == MCSec->getCSectType())
return BSSCsects;
if (XCOFF::XTY_SD == MCSec->getCSectType())
return DataCsects;
report_fatal_error("Unhandled mapping of read-write csect to section.");
return FuncDSCsects;
assert(XCOFF::XTY_CM == MCSec->getCSectType() &&
"Mapping invalid csect. CSECT with bss storage class must be "
"common type.");
return BSSCsects;
assert(XCOFF::XTY_SD == MCSec->getCSectType() &&
"Mapping invalid csect. CSECT with tdata storage class must be "
"an initialized csect.");
return TDataCsects;
assert(XCOFF::XTY_CM == MCSec->getCSectType() &&
"Mapping invalid csect. CSECT with tbss storage class must be "
"an uninitialized csect.");
return TBSSCsects;
case XCOFF::XMC_TC0:
assert(XCOFF::XTY_SD == MCSec->getCSectType() &&
"Only an initialized csect can contain TOC-base.");
assert(TOCCsects.empty() &&
"We should have only one TOC-base, and it should be the first csect "
"in this CsectGroup.");
return TOCCsects;
assert(XCOFF::XTY_SD == MCSec->getCSectType() &&
"Only an initialized csect can contain TC entry.");
assert(!TOCCsects.empty() &&
"We should at least have a TOC-base in this CsectGroup.");
return TOCCsects;
report_fatal_error("Unhandled mapping of csect to section.");
static MCSectionXCOFF *getContainingCsect(const MCSymbolXCOFF *XSym) {
if (XSym->isDefined())
return cast<MCSectionXCOFF>(XSym->getFragment()->getParent());
return XSym->getRepresentedCsect();
void XCOFFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
const MCAsmLayout &Layout) {
if (TargetObjectWriter->is64Bit())
report_fatal_error("64-bit XCOFF object files are not supported yet.");
for (const auto &S : Asm) {
const auto *MCSec = cast<const MCSectionXCOFF>(&S);
assert(SectionMap.find(MCSec) == SectionMap.end() &&
"Cannot add a csect twice.");
assert(XCOFF::XTY_ER != MCSec->getCSectType() &&
"An undefined csect should not get registered.");
// If the name does not fit in the storage provided in the symbol table
// entry, add it to the string table.
if (nameShouldBeInStringTable(MCSec->getSymbolTableName()))
CsectGroup &Group = getCsectGroup(MCSec);
SectionMap[MCSec] = &Group.back();
for (const MCSymbol &S : Asm.symbols()) {
// Nothing to do for temporary symbols.
if (S.isTemporary())
const MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(&S);
const MCSectionXCOFF *ContainingCsect = getContainingCsect(XSym);
if (ContainingCsect->getCSectType() == XCOFF::XTY_ER) {
// Handle undefined symbol.
SectionMap[ContainingCsect] = &UndefinedCsects.back();
if (nameShouldBeInStringTable(ContainingCsect->getSymbolTableName()))
// If the symbol is the csect itself, we don't need to put the symbol
// into csect's Syms.
if (XSym == ContainingCsect->getQualNameSymbol())
// Only put a label into the symbol table when it is an external label.
if (!XSym->isExternal())
assert(SectionMap.find(ContainingCsect) != SectionMap.end() &&
"Expected containing csect to exist in map");
// Lookup the containing csect and add the symbol to it.
// If the name does not fit in the storage provided in the symbol table
// entry, add it to the string table.
if (nameShouldBeInStringTable(XSym->getSymbolTableName()))
void XCOFFObjectWriter::recordRelocation(MCAssembler &Asm,
const MCAsmLayout &Layout,
const MCFragment *Fragment,
const MCFixup &Fixup, MCValue Target,
uint64_t &FixedValue) {
auto getIndex = [this](const MCSymbol *Sym,
const MCSectionXCOFF *ContainingCsect) {
// If we could not find the symbol directly in SymbolIndexMap, this symbol
// could either be a temporary symbol or an undefined symbol. In this case,
// we would need to have the relocation reference its csect instead.
return SymbolIndexMap.find(Sym) != SymbolIndexMap.end()
? SymbolIndexMap[Sym]
: SymbolIndexMap[ContainingCsect->getQualNameSymbol()];
auto getVirtualAddress = [this,
&Layout](const MCSymbol *Sym,
const MCSectionXCOFF *ContainingCsect) {
// If Sym is a csect, return csect's address.
// If Sym is a label, return csect's address + label's offset from the csect.
return SectionMap[ContainingCsect]->Address +
(Sym->isDefined() ? Layout.getSymbolOffset(*Sym) : 0);
const MCSymbol *const SymA = &Target.getSymA()->getSymbol();
MCAsmBackend &Backend = Asm.getBackend();
bool IsPCRel = Backend.getFixupKindInfo(Fixup.getKind()).Flags &
uint8_t Type;
uint8_t SignAndSize;
std::tie(Type, SignAndSize) =
TargetObjectWriter->getRelocTypeAndSignSize(Target, Fixup, IsPCRel);
const MCSectionXCOFF *SymASec = getContainingCsect(cast<MCSymbolXCOFF>(SymA));
assert(SectionMap.find(SymASec) != SectionMap.end() &&
"Expected containing csect to exist in map.");
const uint32_t Index = getIndex(SymA, SymASec);
if (Type == XCOFF::RelocationType::R_POS)
// The FixedValue should be symbol's virtual address in this object file
// plus any constant value that we might get.
FixedValue = getVirtualAddress(SymA, SymASec) + Target.getConstant();
else if (Type == XCOFF::RelocationType::R_TOC ||
Type == XCOFF::RelocationType::R_TOCL) {
// The FixedValue should be the TOC entry offset from the TOC-base plus any
// constant offset value.
const int64_t TOCEntryOffset = SectionMap[SymASec]->Address -
TOCCsects.front().Address +
if (Type == XCOFF::RelocationType::R_TOC && !isInt<16>(TOCEntryOffset))
report_fatal_error("TOCEntryOffset overflows in small code model mode");
FixedValue = TOCEntryOffset;
(TargetObjectWriter->is64Bit() ||
Fixup.getOffset() <= UINT32_MAX - Layout.getFragmentOffset(Fragment)) &&
"Fragment offset + fixup offset is overflowed in 32-bit mode.");
uint32_t FixupOffsetInCsect =
Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
XCOFFRelocation Reloc = {Index, FixupOffsetInCsect, SignAndSize, Type};
MCSectionXCOFF *RelocationSec = cast<MCSectionXCOFF>(Fragment->getParent());
assert(SectionMap.find(RelocationSec) != SectionMap.end() &&
"Expected containing csect to exist in map.");
if (!Target.getSymB())
const MCSymbol *const SymB = &Target.getSymB()->getSymbol();
if (SymA == SymB)
report_fatal_error("relocation for opposite term is not yet supported");
const MCSectionXCOFF *SymBSec = getContainingCsect(cast<MCSymbolXCOFF>(SymB));
assert(SectionMap.find(SymBSec) != SectionMap.end() &&
"Expected containing csect to exist in map.");
if (SymASec == SymBSec)
"relocation for paired relocatable term is not yet supported");
assert(Type == XCOFF::RelocationType::R_POS &&
"SymA must be R_POS here if it's not opposite term or paired "
"relocatable term.");
const uint32_t IndexB = getIndex(SymB, SymBSec);
// SymB must be R_NEG here, given the general form of Target(MCValue) is
// "SymbolA - SymbolB + imm64".
const uint8_t TypeB = XCOFF::RelocationType::R_NEG;
XCOFFRelocation RelocB = {IndexB, FixupOffsetInCsect, SignAndSize, TypeB};
// We already folded "SymbolA + imm64" above when Type is R_POS for SymbolA,
// now we just need to fold "- SymbolB" here.
FixedValue -= getVirtualAddress(SymB, SymBSec);
void XCOFFObjectWriter::writeSections(const MCAssembler &Asm,
const MCAsmLayout &Layout) {
uint32_t CurrentAddressLocation = 0;
for (const auto *Section : Sections) {
// Nothing to write for this Section.
if (Section->Index == Section::UninitializedIndex || Section->IsVirtual)
// There could be a gap (without corresponding zero padding) between
// sections.
assert(((CurrentAddressLocation <= Section->Address) ||
(Section->Flags == XCOFF::STYP_TDATA) ||
(Section->Flags == XCOFF::STYP_TBSS)) &&
"CurrentAddressLocation should be less than or equal to section "
"address if the section is not TData or TBSS.");
CurrentAddressLocation = Section->Address;
for (const auto *Group : Section->Groups) {
for (const auto &Csect : *Group) {
if (uint32_t PaddingSize = Csect.Address - CurrentAddressLocation)
if (Csect.Size)
Asm.writeSectionData(W.OS, Csect.MCCsect, Layout);
CurrentAddressLocation = Csect.Address + Csect.Size;
// The size of the tail padding in a section is the end virtual address of
// the current section minus the the end virtual address of the last csect
// in that section.
if (uint32_t PaddingSize =
Section->Address + Section->Size - CurrentAddressLocation) {
CurrentAddressLocation += PaddingSize;
uint64_t XCOFFObjectWriter::writeObject(MCAssembler &Asm,
const MCAsmLayout &Layout) {
// We always emit a timestamp of 0 for reproducibility, so ensure incremental
// linking is not enabled, in case, like with Windows COFF, such a timestamp
// is incompatible with incremental linking of XCOFF.
if (Asm.isIncrementalLinkerCompatible())
report_fatal_error("Incremental linking not supported for XCOFF.");
if (TargetObjectWriter->is64Bit())
report_fatal_error("64-bit XCOFF object files are not supported yet.");
uint64_t StartOffset = W.OS.tell();
writeSections(Asm, Layout);
// Write the string table.
return W.OS.tell() - StartOffset;
bool XCOFFObjectWriter::nameShouldBeInStringTable(const StringRef &SymbolName) {
return SymbolName.size() > XCOFF::NameSize;
void XCOFFObjectWriter::writeSymbolName(const StringRef &SymbolName) {
if (nameShouldBeInStringTable(SymbolName)) {
} else {
char Name[XCOFF::NameSize+1];
std::strncpy(Name,, XCOFF::NameSize);
ArrayRef<char> NameRef(Name, XCOFF::NameSize);
void XCOFFObjectWriter::writeSymbolTableEntryForCsectMemberLabel(
const Symbol &SymbolRef, const ControlSection &CSectionRef,
int16_t SectionIndex, uint64_t SymbolOffset) {
// Name or Zeros and string table offset
assert(SymbolOffset <= UINT32_MAX - CSectionRef.Address &&
"Symbol address overflows.");
W.write<uint32_t>(CSectionRef.Address + SymbolOffset);
// Basic/Derived type. See the description of the n_type field for symbol
// table entries for a detailed description. Since we don't yet support
// visibility, and all other bits are either optionally set or reserved, this
// is always zero.
// TODO FIXME How to assert a symbol's visibilty is default?
// TODO Set the function indicator (bit 10, 0x0020) for functions
// when debugging is enabled.
// Always 1 aux entry for now.
// Now output the auxiliary entry.
// Parameter typecheck hash. Not supported.
// Typecheck section number. Not supported.
// Symbol type: Label
// Storage mapping class.
// Reserved (x_stab).
// Reserved (x_snstab).
void XCOFFObjectWriter::writeSymbolTableEntryForControlSection(
const ControlSection &CSectionRef, int16_t SectionIndex,
XCOFF::StorageClass StorageClass) {
// n_name, n_zeros, n_offset
// n_value
// n_scnum
// Basic/Derived type. See the description of the n_type field for symbol
// table entries for a detailed description. Since we don't yet support
// visibility, and all other bits are either optionally set or reserved, this
// is always zero.
// TODO FIXME How to assert a symbol's visibilty is default?
// TODO Set the function indicator (bit 10, 0x0020) for functions
// when debugging is enabled.
// n_sclass
// Always 1 aux entry for now.
// Now output the auxiliary entry.
// Parameter typecheck hash. Not supported.
// Typecheck section number. Not supported.
// Symbol type.
// Storage mapping class.
// Reserved (x_stab).
// Reserved (x_snstab).
void XCOFFObjectWriter::writeFileHeader() {
// Magic.
// Number of sections.
// Timestamp field. For reproducible output we write a 0, which represents no
// timestamp.
// Byte Offset to the start of the symbol table.
// Number of entries in the symbol table.
// Size of the optional header.
// Flags.
void XCOFFObjectWriter::writeSectionHeaderTable() {
for (const auto *Sec : Sections) {
// Nothing to write for this Section.
if (Sec->Index == Section::UninitializedIndex)
// Write Name.
ArrayRef<char> NameRef(Sec->Name, XCOFF::NameSize);
// Write the Physical Address and Virtual Address. In an object file these
// are the same.
// Line number pointer. Not supported yet.
// Line number counts. Not supported yet.
void XCOFFObjectWriter::writeRelocation(XCOFFRelocation Reloc,
const ControlSection &CSection) {
W.write<uint32_t>(CSection.Address + Reloc.FixupOffsetInCsect);
void XCOFFObjectWriter::writeRelocations() {
for (const auto *Section : Sections) {
if (Section->Index == Section::UninitializedIndex)
// Nothing to write for this Section.
for (const auto *Group : Section->Groups) {
if (Group->empty())
for (const auto &Csect : *Group) {
for (const auto Reloc : Csect.Relocations)
writeRelocation(Reloc, Csect);
void XCOFFObjectWriter::writeSymbolTable(const MCAsmLayout &Layout) {
// Write symbol 0 as C_FILE.
// FIXME: support 64-bit C_FILE symbol.
// n_name. The n_name of a C_FILE symbol is the source filename when no
// auxiliary entries are present. The source filename is alternatively
// provided by an auxiliary entry, in which case the n_name of the C_FILE
// symbol is `.file`.
// FIXME: add the real source filename.
// n_value. The n_value of a C_FILE symbol is its symbol table index.
// n_scnum. N_DEBUG is a reserved section number for indicating a special
// symbolic debugging symbol.
// n_type. The n_type field of a C_FILE symbol encodes the source language and
// CPU version info; zero indicates no info.
// n_sclass. The C_FILE symbol provides source file-name information,
// source-language ID and CPU-version ID information and some other optional
// infos.
// n_numaux. No aux entry for now.
for (const auto &Csect : UndefinedCsects) {
Csect, XCOFF::ReservedSectionNum::N_UNDEF, Csect.MCCsect->getStorageClass());
for (const auto *Section : Sections) {
if (Section->Index == Section::UninitializedIndex)
// Nothing to write for this Section.
for (const auto *Group : Section->Groups) {
if (Group->empty())
const int16_t SectionIndex = Section->Index;
for (const auto &Csect : *Group) {
// Write out the control section first and then each symbol in it.
Csect, SectionIndex, Csect.MCCsect->getStorageClass());
for (const auto &Sym : Csect.Syms)
Sym, Csect, SectionIndex, Layout.getSymbolOffset(*(Sym.MCSym)));
void XCOFFObjectWriter::finalizeSectionInfo() {
for (auto *Section : Sections) {
if (Section->Index == Section::UninitializedIndex)
// Nothing to record for this Section.
for (const auto *Group : Section->Groups) {
if (Group->empty())
for (auto &Csect : *Group) {
const size_t CsectRelocCount = Csect.Relocations.size();
if (CsectRelocCount >= XCOFF::RelocOverflow ||
Section->RelocationCount >= XCOFF::RelocOverflow - CsectRelocCount)
"relocation entries overflowed; overflow section is "
"not implemented yet");
Section->RelocationCount += CsectRelocCount;
// Calculate the file offset to the relocation entries.
uint64_t RawPointer = RelocationEntryOffset;
for (auto Sec : Sections) {
if (Sec->Index == Section::UninitializedIndex || !Sec->RelocationCount)
Sec->FileOffsetToRelocations = RawPointer;
const uint32_t RelocationSizeInSec =
Sec->RelocationCount * XCOFF::RelocationSerializationSize32;
RawPointer += RelocationSizeInSec;
if (RawPointer > UINT32_MAX)
report_fatal_error("Relocation data overflowed this object file.");
// TODO Error check that the number of symbol table entries fits in 32-bits
// signed ...
if (SymbolTableEntryCount)
SymbolTableOffset = RawPointer;
void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
// The first symbol table entry (at index 0) is for the file name.
uint32_t SymbolTableIndex = 1;
// Calculate indices for undefined symbols.
for (auto &Csect : UndefinedCsects) {
Csect.Size = 0;
Csect.Address = 0;
Csect.SymbolTableIndex = SymbolTableIndex;
SymbolIndexMap[Csect.MCCsect->getQualNameSymbol()] = Csect.SymbolTableIndex;
// 1 main and 1 auxiliary symbol table entry for each contained symbol.
SymbolTableIndex += 2;
// The address corrresponds to the address of sections and symbols in the
// object file. We place the shared address 0 immediately after the
// section header table.
uint32_t Address = 0;
// Section indices are 1-based in XCOFF.
int32_t SectionIndex = 1;
bool HasTDataSection = false;
for (auto *Section : Sections) {
const bool IsEmpty =
[](const CsectGroup *Group) { return Group->empty(); });
if (IsEmpty)
if (SectionIndex > MaxSectionIndex)
report_fatal_error("Section index overflow!");
Section->Index = SectionIndex++;
bool SectionAddressSet = false;
// Reset the starting address to 0 for TData section.
if (Section->Flags == XCOFF::STYP_TDATA) {
Address = 0;
HasTDataSection = true;
// Reset the starting address to 0 for TBSS section if the object file does
// not contain TData Section.
if ((Section->Flags == XCOFF::STYP_TBSS) && !HasTDataSection)
Address = 0;
for (auto *Group : Section->Groups) {
if (Group->empty())
for (auto &Csect : *Group) {
const MCSectionXCOFF *MCSec = Csect.MCCsect;
Csect.Address = alignTo(Address, MCSec->getAlignment());
Csect.Size = Layout.getSectionAddressSize(MCSec);
Address = Csect.Address + Csect.Size;
Csect.SymbolTableIndex = SymbolTableIndex;
SymbolIndexMap[MCSec->getQualNameSymbol()] = Csect.SymbolTableIndex;
// 1 main and 1 auxiliary symbol table entry for the csect.
SymbolTableIndex += 2;
for (auto &Sym : Csect.Syms) {
Sym.SymbolTableIndex = SymbolTableIndex;
SymbolIndexMap[Sym.MCSym] = Sym.SymbolTableIndex;
// 1 main and 1 auxiliary symbol table entry for each contained
// symbol.
SymbolTableIndex += 2;
if (!SectionAddressSet) {
Section->Address = Group->front().Address;
SectionAddressSet = true;
// Make sure the address of the next section aligned to
// DefaultSectionAlign.
Address = alignTo(Address, DefaultSectionAlign);
Section->Size = Address - Section->Address;
SymbolTableEntryCount = SymbolTableIndex;
// Calculate the RawPointer value for each section.
uint64_t RawPointer = sizeof(XCOFF::FileHeader32) + auxiliaryHeaderSize() +
SectionCount * sizeof(XCOFF::SectionHeader32);
for (auto *Sec : Sections) {
if (Sec->Index == Section::UninitializedIndex || Sec->IsVirtual)
Sec->FileOffsetToData = RawPointer;
RawPointer += Sec->Size;
if (RawPointer > UINT32_MAX)
report_fatal_error("Section raw data overflowed this object file.");
RelocationEntryOffset = RawPointer;
// Takes the log base 2 of the alignment and shifts the result into the 5 most
// significant bits of a byte, then or's in the csect type into the least
// significant 3 bits.
uint8_t getEncodedType(const MCSectionXCOFF *Sec) {
unsigned Align = Sec->getAlignment();
assert(isPowerOf2_32(Align) && "Alignment must be a power of 2.");
unsigned Log2Align = Log2_32(Align);
// Result is a number in the range [0, 31] which fits in the 5 least
// significant bits. Shift this value into the 5 most significant bits, and
// bitwise-or in the csect type.
uint8_t EncodedAlign = Log2Align << 3;
return EncodedAlign | Sec->getCSectType();
} // end anonymous namespace
llvm::createXCOFFObjectWriter(std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW,
raw_pwrite_stream &OS) {
return std::make_unique<XCOFFObjectWriter>(std::move(MOTW), OS);