Write out global initializers and data rel directly to ELF file.
The local symbol relocations are a bit different from
llvm-mc, which are section-relative. E.g., instead "bytes",
it will be ".data + offsetof(bytes, .data)". So the
contents of the text/data/rodata sections can also differ
since the offsets written in place are different.
Still need to fill the symbol table with undefined
symbols (e.g., memset, and szrt lib functions) before
trying to link.
BUG=none
R=kschimpf@google.com, stichnot@chromium.org
Review URL: https://codereview.chromium.org/874353006
diff --git a/src/IceConverter.cpp b/src/IceConverter.cpp
index 0be0f28..e8ec56d 100644
--- a/src/IceConverter.cpp
+++ b/src/IceConverter.cpp
@@ -643,9 +643,8 @@
/// Converts global variables, and their initializers into ICE
/// global variable declarations, for module Mod. Puts corresponding
/// converted declarations into VariableDeclarations.
- void convertGlobalsToIce(
- Module *Mod,
- Ice::Translator::VariableDeclarationListType &VariableDeclarations);
+ void convertGlobalsToIce(Module *Mod,
+ Ice::VariableDeclarationList &VariableDeclarations);
private:
// Adds the Initializer to the list of initializers for the Global
@@ -681,8 +680,7 @@
};
void LLVM2ICEGlobalsConverter::convertGlobalsToIce(
- Module *Mod,
- Ice::Translator::VariableDeclarationListType &VariableDeclarations) {
+ Module *Mod, Ice::VariableDeclarationList &VariableDeclarations) {
for (Module::const_global_iterator I = Mod->global_begin(),
E = Mod->global_end();
I != E; ++I) {
@@ -868,7 +866,7 @@
void Converter::convertGlobals(Module *Mod) {
LLVM2ICEGlobalsConverter GlobalsConverter(*this);
- Translator::VariableDeclarationListType VariableDeclarations;
+ VariableDeclarationList VariableDeclarations;
GlobalsConverter.convertGlobalsToIce(Mod, VariableDeclarations);
lowerGlobals(VariableDeclarations);
}
diff --git a/src/IceDefs.h b/src/IceDefs.h
index e7d97db..368e92c 100644
--- a/src/IceDefs.h
+++ b/src/IceDefs.h
@@ -60,7 +60,7 @@
class LiveRange;
class Liveness;
class Operand;
-class TargetGlobalLowering;
+class TargetDataLowering;
class TargetLowering;
class Variable;
class VariableDeclaration;
@@ -103,6 +103,8 @@
typedef std::vector<CfgNode *, CfgLocalAllocator<CfgNode *>> NodeList;
typedef std::vector<Constant *> ConstantList;
+typedef std::vector<VariableDeclaration *> VariableDeclarationList;
+
// SizeT is for holding small-ish limits like number of source
// operands in an instruction. It is used instead of size_t (which
// may be 64-bits wide) when we want to save space.
diff --git a/src/IceELFObjectWriter.cpp b/src/IceELFObjectWriter.cpp
index c4ff4f0..d15c735 100644
--- a/src/IceELFObjectWriter.cpp
+++ b/src/IceELFObjectWriter.cpp
@@ -11,6 +11,8 @@
//
//===----------------------------------------------------------------------===//
+#include "llvm/Support/MathExtras.h"
+
#include "assembler.h"
#include "IceDefs.h"
#include "IceELFObjectWriter.h"
@@ -103,6 +105,28 @@
return NewSection;
}
+ELFRelocationSection *
+ELFObjectWriter::createRelocationSection(bool IsELF64,
+ const ELFSection *RelatedSection) {
+ // Choice of RELA vs REL is actually separate from elf64 vs elf32,
+ // but in practice we've only had .rela for elf64 (x86-64).
+ // In the future, the two properties may need to be decoupled
+ // and the ShEntSize can vary more.
+ const Elf64_Word ShType = IsELF64 ? SHT_RELA : SHT_REL;
+ IceString RelPrefix = IsELF64 ? ".rela" : ".rel";
+ IceString RelSectionName = RelPrefix + RelatedSection->getName();
+ const Elf64_Xword ShAlign = IsELF64 ? 8 : 4;
+ const Elf64_Xword ShEntSize =
+ IsELF64 ? sizeof(Elf64_Rela) : sizeof(Elf32_Rel);
+ static_assert(sizeof(Elf64_Rela) == 24 && sizeof(Elf32_Rel) == 8,
+ "Elf_Rel/Rela sizes cannot be derived from sizeof");
+ const Elf64_Xword ShFlags = 0;
+ ELFRelocationSection *RelSection = createSection<ELFRelocationSection>(
+ RelSectionName, ShType, ShFlags, ShAlign, ShEntSize);
+ RelSection->setRelatedSection(RelatedSection);
+ return RelSection;
+}
+
template <typename UserSectionList>
void ELFObjectWriter::assignRelSectionNumInPairs(SizeT &CurSectionNumber,
UserSectionList &UserSections,
@@ -150,8 +174,13 @@
RelTextSections, AllSections);
assignRelSectionNumInPairs<DataSectionList>(CurSectionNumber, DataSections,
RelDataSections, AllSections);
- assignRelSectionNumInPairs<DataSectionList>(CurSectionNumber, RoDataSections,
- RelRoDataSections, AllSections);
+ for (ELFSection *BSSSection : BSSSections) {
+ BSSSection->setNumber(CurSectionNumber++);
+ BSSSection->setNameStrIndex(ShStrTab->getIndex(BSSSection->getName()));
+ AllSections.push_back(BSSSection);
+ }
+ assignRelSectionNumInPairs<DataSectionList>(CurSectionNumber, RODataSections,
+ RelRODataSections, AllSections);
ShStrTab->setNumber(CurSectionNumber++);
ShStrTab->setNameStrIndex(ShStrTab->getIndex(ShStrTab->getName()));
@@ -170,20 +199,17 @@
assignRelLinkNum(SymTab->getNumber(), RelTextSections);
assignRelLinkNum(SymTab->getNumber(), RelDataSections);
- assignRelLinkNum(SymTab->getNumber(), RelRoDataSections);
+ assignRelLinkNum(SymTab->getNumber(), RelRODataSections);
SectionNumbersAssigned = true;
}
Elf64_Off ELFObjectWriter::alignFileOffset(Elf64_Xword Align) {
- assert(llvm::isPowerOf2_32(Align));
Elf64_Off OffsetInFile = Str.tell();
- Elf64_Xword Mod = OffsetInFile & (Align - 1);
- if (Mod == 0)
+ Elf64_Xword AlignDiff = Utils::OffsetToAlignment(OffsetInFile, Align);
+ if (AlignDiff == 0)
return OffsetInFile;
- Elf64_Xword AlignDiff = Align - Mod;
Str.writeZeroPadding(AlignDiff);
OffsetInFile += AlignDiff;
- assert((OffsetInFile & (Align - 1)) == 0);
return OffsetInFile;
}
@@ -191,9 +217,11 @@
bool IsInternal, const Assembler *Asm) {
assert(!SectionNumbersAssigned);
ELFTextSection *Section = nullptr;
- // TODO(jvoung): handle ffunction-sections.
- IceString SectionName = ".text";
- if (TextSections.size() == 0) {
+ ELFRelocationSection *RelSection = nullptr;
+ if (TextSections.empty()) {
+ // TODO(jvoung): handle ffunction-sections.
+ IceString SectionName = ".text";
+ bool IsELF64 = isELF64(Ctx.getTargetArch());
const Elf64_Xword ShFlags = SHF_ALLOC | SHF_EXECINSTR;
// TODO(jvoung): Should be bundle size. Grab it from that target?
const Elf64_Xword ShAlign = 32;
@@ -202,8 +230,11 @@
Elf64_Off OffsetInFile = alignFileOffset(Section->getSectionAlign());
Section->setFileOffset(OffsetInFile);
TextSections.push_back(Section);
+ RelSection = createRelocationSection(IsELF64, Section);
+ RelTextSections.push_back(RelSection);
} else {
Section = TextSections[0];
+ RelSection = RelTextSections[0];
}
RelocOffsetT OffsetInSection = Section->getCurrentSize();
// Function symbols are set to 0 size in the symbol table,
@@ -227,41 +258,158 @@
// fixup information from per-function Assembler memory to the object
// writer's memory, for writing later.
if (!Asm->fixups().empty()) {
- bool IsELF64 = isELF64(Ctx.getTargetArch());
- IceString RelSectionName = IsELF64 ? ".rela" : ".rel";
- RelSectionName += SectionName;
- ELFRelocationSection *RelSection = nullptr;
- // TODO(jvoung): Make this more efficient if -ffunction-sections
- // efficiency becomes a problem.
- auto RSI =
- std::find_if(RelTextSections.begin(), RelTextSections.end(),
- [&RelSectionName](const ELFRelocationSection *S)
- -> bool { return S->getName() == RelSectionName; });
- if (RSI != RelTextSections.end()) {
- RelSection = *RSI;
- } else {
- const Elf64_Word ShType = IsELF64 ? SHT_RELA : SHT_REL;
- const Elf64_Xword ShAlign = IsELF64 ? 8 : 4;
- const Elf64_Xword ShEntSize =
- IsELF64 ? sizeof(Elf64_Rela) : sizeof(Elf32_Rel);
- static_assert(sizeof(Elf64_Rela) == 24 && sizeof(Elf32_Rel) == 8,
- "Elf_Rel/Rela sizes cannot be derived from sizeof");
- const Elf64_Xword ShFlags = 0;
- RelSection = createSection<ELFRelocationSection>(
- RelSectionName, ShType, ShFlags, ShAlign, ShEntSize);
- RelSection->setRelatedSection(Section);
- RelTextSections.push_back(RelSection);
- }
RelSection->addRelocations(OffsetInSection, Asm->fixups());
}
}
-void ELFObjectWriter::writeDataInitializer(const IceString &VarName,
- const llvm::StringRef Data) {
+namespace {
+
+ELFObjectWriter::SectionType
+classifyGlobalSection(const VariableDeclaration *Var) {
+ if (Var->getIsConstant())
+ return ELFObjectWriter::ROData;
+ if (Var->hasNonzeroInitializer())
+ return ELFObjectWriter::Data;
+ return ELFObjectWriter::BSS;
+}
+
+// Partition the Vars list by SectionType into VarsBySection.
+// If TranslateOnly is non-empty, then only the TranslateOnly variable
+// is kept for emission.
+void partitionGlobalsBySection(const VariableDeclarationList &Vars,
+ VariableDeclarationList VarsBySection[],
+ const IceString &TranslateOnly) {
+ for (VariableDeclaration *Var : Vars) {
+ if (GlobalContext::matchSymbolName(Var->getName(), TranslateOnly)) {
+ size_t Section = classifyGlobalSection(Var);
+ assert(Section < ELFObjectWriter::SectionType::NumSectionTypes);
+ VarsBySection[Section].push_back(Var);
+ }
+ }
+}
+
+} // end of anonymous namespace
+
+void ELFObjectWriter::writeDataSection(const VariableDeclarationList &Vars,
+ FixupKind RelocationKind) {
assert(!SectionNumbersAssigned);
- (void)Data;
- llvm_unreachable("TODO");
- StrTab->add(VarName);
+ VariableDeclarationList VarsBySection[ELFObjectWriter::NumSectionTypes];
+ for (auto &SectionList : VarsBySection)
+ SectionList.reserve(Vars.size());
+ partitionGlobalsBySection(Vars, VarsBySection, Ctx.getFlags().TranslateOnly);
+ bool IsELF64 = isELF64(Ctx.getTargetArch());
+ size_t I = 0;
+ for (auto &SectionList : VarsBySection) {
+ writeDataOfType(static_cast<SectionType>(I++), SectionList, RelocationKind,
+ IsELF64);
+ }
+}
+
+void ELFObjectWriter::writeDataOfType(SectionType SectionType,
+ const VariableDeclarationList &Vars,
+ FixupKind RelocationKind, bool IsELF64) {
+ ELFDataSection *Section;
+ ELFRelocationSection *RelSection;
+ // TODO(jvoung): Handle fdata-sections.
+ IceString SectionName;
+ Elf64_Xword ShAddralign = 0;
+ for (VariableDeclaration *Var : Vars) {
+ Elf64_Xword Align = Var->getAlignment();
+ ShAddralign = std::max(ShAddralign, Align);
+ }
+ const Elf64_Xword ShEntsize = 0; // non-uniform data element size.
+ // Lift this out, so it can be re-used if we do fdata-sections?
+ switch (SectionType) {
+ case SectionType::ROData: {
+ SectionName = ".rodata";
+ // Only expecting to write the data sections all in one shot for now.
+ assert(RODataSections.empty());
+ const Elf64_Xword ShFlags = SHF_ALLOC;
+ Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, ShFlags,
+ ShAddralign, ShEntsize);
+ Section->setFileOffset(alignFileOffset(ShAddralign));
+ RODataSections.push_back(Section);
+ RelSection = createRelocationSection(IsELF64, Section);
+ RelRODataSections.push_back(RelSection);
+ break;
+ }
+ case SectionType::Data: {
+ SectionName = ".data";
+ assert(DataSections.empty());
+ const Elf64_Xword ShFlags = SHF_ALLOC | SHF_WRITE;
+ Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, ShFlags,
+ ShAddralign, ShEntsize);
+ Section->setFileOffset(alignFileOffset(ShAddralign));
+ DataSections.push_back(Section);
+ RelSection = createRelocationSection(IsELF64, Section);
+ RelDataSections.push_back(RelSection);
+ break;
+ }
+ case SectionType::BSS: {
+ SectionName = ".bss";
+ assert(BSSSections.empty());
+ const Elf64_Xword ShFlags = SHF_ALLOC | SHF_WRITE;
+ Section = createSection<ELFDataSection>(SectionName, SHT_NOBITS, ShFlags,
+ ShAddralign, ShEntsize);
+ Section->setFileOffset(alignFileOffset(ShAddralign));
+ BSSSections.push_back(Section);
+ break;
+ }
+ case SectionType::NumSectionTypes:
+ llvm::report_fatal_error("Unknown SectionType");
+ break;
+ }
+
+ const uint8_t SymbolType = STT_OBJECT;
+ for (VariableDeclaration *Var : Vars) {
+ Elf64_Xword Align = Var->getAlignment();
+ Section->padToAlignment(Str, Align);
+ SizeT SymbolSize = Var->getNumBytes();
+ bool IsExternal = Var->isExternal() || Ctx.getFlags().DisableInternal;
+ const uint8_t SymbolBinding = IsExternal ? STB_GLOBAL : STB_LOCAL;
+ IceString MangledName = Var->mangleName(&Ctx);
+ SymTab->createDefinedSym(MangledName, SymbolType, SymbolBinding, Section,
+ Section->getCurrentSize(), SymbolSize);
+ StrTab->add(MangledName);
+ if (!Var->hasNonzeroInitializer()) {
+ assert(SectionType == SectionType::BSS ||
+ SectionType == SectionType::ROData);
+ if (SectionType == SectionType::ROData)
+ Section->appendZeros(Str, SymbolSize);
+ else
+ Section->setSize(Section->getCurrentSize() + SymbolSize);
+ } else {
+ assert(SectionType != SectionType::BSS);
+ for (VariableDeclaration::Initializer *Init : Var->getInitializers()) {
+ switch (Init->getKind()) {
+ case VariableDeclaration::Initializer::DataInitializerKind: {
+ const auto Data = llvm::cast<VariableDeclaration::DataInitializer>(
+ Init)->getContents();
+ Section->appendData(Str, llvm::StringRef(Data.data(), Data.size()));
+ break;
+ }
+ case VariableDeclaration::Initializer::ZeroInitializerKind:
+ Section->appendZeros(Str, Init->getNumBytes());
+ break;
+ case VariableDeclaration::Initializer::RelocInitializerKind: {
+ const auto Reloc =
+ llvm::cast<VariableDeclaration::RelocInitializer>(Init);
+ AssemblerFixup NewFixup;
+ NewFixup.set_position(Section->getCurrentSize());
+ NewFixup.set_kind(RelocationKind);
+ const bool SuppressMangling = true;
+ NewFixup.set_value(Ctx.getConstantSym(
+ Reloc->getOffset(), Reloc->getDeclaration()->mangleName(&Ctx),
+ SuppressMangling));
+ RelSection->addRelocation(NewFixup);
+ Section->appendRelocationOffset(Str, RelSection->isRela(),
+ Reloc->getOffset());
+ break;
+ }
+ }
+ }
+ }
+ }
}
void ELFObjectWriter::writeInitialELFHeader() {
@@ -345,7 +493,7 @@
SecStrBuf << ".rodata.cst" << WriteAmt;
ELFDataSection *Section = createSection<ELFDataSection>(
SecStrBuf.str(), SHT_PROGBITS, ShFlags, Align, WriteAmt);
- RoDataSections.push_back(Section);
+ RODataSections.push_back(Section);
SizeT OffsetInSection = 0;
// The symbol table entry doesn't need to know the defined symbol's
// size since this is in a section with a fixed Entry Size.
@@ -382,7 +530,7 @@
void ELFObjectWriter::writeAllRelocationSections(bool IsELF64) {
writeRelocationSections(IsELF64, RelTextSections);
writeRelocationSections(IsELF64, RelDataSections);
- writeRelocationSections(IsELF64, RelRoDataSections);
+ writeRelocationSections(IsELF64, RelRODataSections);
}
void ELFObjectWriter::writeRelocationSections(bool IsELF64,
diff --git a/src/IceELFObjectWriter.h b/src/IceELFObjectWriter.h
index 9f468cb..74fee5e 100644
--- a/src/IceELFObjectWriter.h
+++ b/src/IceELFObjectWriter.h
@@ -29,10 +29,23 @@
// After all definitions are written out, it will finalize the bookkeeping
// sections and write them out. Expected usage:
//
-// (1) writeInitialELFHeader
-// (2) writeDataInitializer*
-// (3) writeFunctionCode*
-// (4) writeNonUserSections
+// (1) writeInitialELFHeader (invoke once)
+// (2) writeDataSection (invoke once)
+// (3) writeFunctionCode (must invoke once per function)
+// (4) writeConstantPool (must invoke once per pooled primitive type)
+// (5) writeNonUserSections (invoke once)
+//
+// The requirement for writeDataSection to be invoked only once can
+// be relaxed if using -fdata-sections. The requirement to invoke only once
+// without -fdata-sections is so that variables that belong to each possible
+// SectionType are contiguous in the file. With -fdata-sections, each global
+// variable is in a separate section and therefore the sections will be
+// trivially contiguous.
+//
+// The motivation for requiring that writeFunctionCode happen after
+// writeDataSection: to keep the .text and .data sections contiguous in the
+// file. Having both -fdata-sections and -ffunction-sections does allow
+// relaxing this requirement.
class ELFObjectWriter {
ELFObjectWriter(const ELFObjectWriter &) = delete;
ELFObjectWriter &operator=(const ELFObjectWriter &) = delete;
@@ -45,26 +58,32 @@
// and data directly to the file and get the right file offsets.
void writeInitialELFHeader();
+ // Copy initializer data for globals to file and note the offset and size
+ // of each global's definition in the symbol table.
+ // Use the given target's RelocationKind for any relocations.
+ void writeDataSection(const VariableDeclarationList &Vars,
+ FixupKind RelocationKind);
+
// Copy data of a function's text section to file and note the offset of the
// symbol's definition in the symbol table.
// Copy the text fixups for use after all functions are written.
+ // The text buffer and fixups are extracted from the Assembler object.
void writeFunctionCode(const IceString &FuncName, bool IsInternal,
const Assembler *Asm);
- // Copy initializer data for a global to file and note the offset and
- // size of the global's definition in the symbol table.
- // TODO(jvoung): This needs to know which section. This also needs the
- // relocations to hook them up to the symbol table references. Also
- // TODO is handling BSS (which just needs to note the size).
- void writeDataInitializer(const IceString &VarName,
- const llvm::StringRef Data);
-
+ // Queries the GlobalContext for constant pools of the given type
+ // and writes out read-only data sections for those constants. This also
+ // fills the symbol table with labels for each constant pool entry.
template <typename ConstType> void writeConstantPool(Type Ty);
- // Do final layout and write out the rest of the object file, then
- // patch up the initial ELF header with the final info.
+ // Do final layout and write out the rest of the object file.
+ // Finally, patch up the initial ELF header with the final info.
void writeNonUserSections();
+ // Which type of ELF section a global variable initializer belongs to.
+ // This is used as an array index so should start at 0 and be contiguous.
+ enum SectionType { ROData = 0, Data, BSS, NumSectionTypes };
+
private:
GlobalContext &Ctx;
ELFStreamer &Str;
@@ -79,8 +98,9 @@
RelSectionList RelTextSections;
DataSectionList DataSections;
RelSectionList RelDataSections;
- DataSectionList RoDataSections;
- RelSectionList RelRoDataSections;
+ DataSectionList RODataSections;
+ RelSectionList RelRODataSections;
+ DataSectionList BSSSections;
// Handles to special sections that need incremental bookkeeping.
ELFSection *NullSection;
@@ -93,6 +113,11 @@
Elf64_Xword ShFlags, Elf64_Xword ShAddralign,
Elf64_Xword ShEntsize);
+ // Create a relocation section, given the related section
+ // (e.g., .text, .data., .rodata).
+ ELFRelocationSection *
+ createRelocationSection(bool IsELF64, const ELFSection *RelatedSection);
+
// Align the file position before writing out a section's data,
// and return the position of the file.
Elf64_Off alignFileOffset(Elf64_Xword Align);
@@ -116,6 +141,12 @@
// Link the relocation sections to the symbol table.
void assignRelLinkNum(SizeT SymTabNumber, RelSectionList &RelSections);
+ // Helper function for writeDataSection. Writes a data section of type
+ // SectionType, given the global variables Vars belonging to that SectionType.
+ void writeDataOfType(SectionType SectionType,
+ const VariableDeclarationList &Vars,
+ FixupKind RelocationKind, bool IsELF64);
+
// Write the final relocation sections given the final symbol table.
// May also be able to seek around the file and resolve function calls
// that are for functions within the same section.
diff --git a/src/IceELFSection.cpp b/src/IceELFSection.cpp
index 5dcc206..f6fb526 100644
--- a/src/IceELFSection.cpp
+++ b/src/IceELFSection.cpp
@@ -11,6 +11,8 @@
//
//===----------------------------------------------------------------------===//
+#include "llvm/Support/MathExtras.h"
+
#include "IceDefs.h"
#include "IceELFSection.h"
#include "IceELFStreamer.h"
@@ -35,6 +37,32 @@
Header.sh_size += MoreData.size();
}
+void ELFDataSection::appendZeros(ELFStreamer &Str, SizeT NumBytes) {
+ Str.writeZeroPadding(NumBytes);
+ Header.sh_size += NumBytes;
+}
+
+void ELFDataSection::appendRelocationOffset(ELFStreamer &Str, bool IsRela,
+ RelocOffsetT RelocOffset) {
+ if (IsRela) {
+ appendZeros(Str, RelocAddrSize);
+ return;
+ }
+ static_assert(RelocAddrSize == 4, " writeLE32 assumes RelocAddrSize is 4");
+ Str.writeLE32(RelocOffset);
+ Header.sh_size += RelocAddrSize;
+}
+
+void ELFDataSection::padToAlignment(ELFStreamer &Str, Elf64_Xword Align) {
+ assert(llvm::isPowerOf2_32(Align));
+ Elf64_Xword AlignDiff = Utils::OffsetToAlignment(Header.sh_size, Align);
+ if (AlignDiff == 0)
+ return;
+ if (Header.sh_type != llvm::ELF::SHT_NOBITS)
+ Str.writeZeroPadding(AlignDiff);
+ Header.sh_size += AlignDiff;
+}
+
// Relocation sections.
void ELFRelocationSection::addRelocations(RelocOffsetT BaseOff,
@@ -73,7 +101,7 @@
NewSymbol.Section = Section;
NewSymbol.Number = ELFSym::UnknownNumber;
bool Unique;
- if (Type == STB_LOCAL)
+ if (Binding == STB_LOCAL)
Unique = LocalSymbols.insert(std::make_pair(Name, NewSymbol)).second;
else
Unique = GlobalSymbols.insert(std::make_pair(Name, NewSymbol)).second;
diff --git a/src/IceELFSection.h b/src/IceELFSection.h
index 5821a83..db000f4 100644
--- a/src/IceELFSection.h
+++ b/src/IceELFSection.h
@@ -117,6 +117,16 @@
using ELFSection::ELFSection;
void appendData(ELFStreamer &Str, const llvm::StringRef MoreData);
+
+ void appendZeros(ELFStreamer &Str, SizeT NumBytes);
+
+ void appendRelocationOffset(ELFStreamer &Str, bool IsRela,
+ RelocOffsetT RelocOffset);
+
+ // Pad the next section offset for writing data elements to the requested
+ // alignment. If the section is NOBITS then do not actually write out
+ // the padding and only update the section size.
+ void padToAlignment(ELFStreamer &Str, Elf64_Xword Align);
};
// Model of ELF symbol table entries. Besides keeping track of the fields
@@ -195,13 +205,18 @@
public:
using ELFSection::ELFSection;
- ELFSection *getRelatedSection() const { return RelatedSection; }
- void setRelatedSection(ELFSection *Section) { RelatedSection = Section; }
+ const ELFSection *getRelatedSection() const { return RelatedSection; }
+ void setRelatedSection(const ELFSection *Section) {
+ RelatedSection = Section;
+ }
// Track additional relocations which start out relative to offset 0,
// but should be adjusted to be relative to BaseOff.
void addRelocations(RelocOffsetT BaseOff, const FixupRefList &FixupRefs);
+ // Track a single additional relocation.
+ void addRelocation(const AssemblerFixup &Fixup) { Fixups.push_back(Fixup); }
+
size_t getSectionDataSize(const GlobalContext &Ctx,
const ELFSymbolTableSection *SymTab) const;
@@ -209,8 +224,10 @@
void writeData(const GlobalContext &Ctx, ELFStreamer &Str,
const ELFSymbolTableSection *SymTab);
+ bool isRela() const { return Header.sh_type == SHT_RELA; }
+
private:
- ELFSection *RelatedSection;
+ const ELFSection *RelatedSection;
FixupList Fixups;
};
diff --git a/src/IceGlobalInits.h b/src/IceGlobalInits.h
index 3478a98..36d4612 100644
--- a/src/IceGlobalInits.h
+++ b/src/IceGlobalInits.h
@@ -157,7 +157,7 @@
};
// Models the data in a data initializer.
- typedef std::vector<uint8_t> DataVecType;
+ typedef std::vector<char> DataVecType;
/// Defines a sequence of byte values as a data initializer.
class DataInitializer : public Initializer {
@@ -170,14 +170,14 @@
: Initializer(DataInitializerKind), Contents(Values.size()) {
size_t i = 0;
for (auto &V : Values) {
- Contents[i] = static_cast<uint8_t>(V);
+ Contents[i] = static_cast<int8_t>(V);
++i;
}
}
DataInitializer(const char *Str, size_t StrLen)
: Initializer(DataInitializerKind), Contents(StrLen) {
for (size_t i = 0; i < StrLen; ++i)
- Contents[i] = static_cast<uint8_t>(Str[i]);
+ Contents[i] = Str[i];
}
~DataInitializer() override {}
const DataVecType &getContents() const { return Contents; }
diff --git a/src/IceTargetLowering.cpp b/src/IceTargetLowering.cpp
index 27a2d60..8b7c257 100644
--- a/src/IceTargetLowering.cpp
+++ b/src/IceTargetLowering.cpp
@@ -252,24 +252,24 @@
LinearScan.scan(RegMask, RandomizeRegisterAllocation);
}
-TargetGlobalLowering *TargetGlobalLowering::createLowering(GlobalContext *Ctx) {
+TargetDataLowering *TargetDataLowering::createLowering(GlobalContext *Ctx) {
// These statements can be #ifdef'd to specialize the code generator
// to a subset of the available targets. TODO: use CRTP.
TargetArch Target = Ctx->getTargetArch();
if (Target == Target_X8632)
- return TargetGlobalX8632::create(Ctx);
+ return TargetDataX8632::create(Ctx);
#if 0
if (Target == Target_X8664)
- return TargetGlobalX8664::create(Ctx);
+ return TargetDataX8664::create(Ctx);
if (Target == Target_ARM32)
- return TargetGlobalARM32::create(Ctx);
+ return TargetDataARM32::create(Ctx);
if (Target == Target_ARM64)
- return TargetGlobalARM64::create(Ctx);
+ return TargetDataARM64::create(Ctx);
#endif
llvm_unreachable("Unsupported target");
return nullptr;
}
-TargetGlobalLowering::~TargetGlobalLowering() {}
+TargetDataLowering::~TargetDataLowering() {}
} // end of namespace Ice
diff --git a/src/IceTargetLowering.h b/src/IceTargetLowering.h
index 17d785e..2dda5c5 100644
--- a/src/IceTargetLowering.h
+++ b/src/IceTargetLowering.h
@@ -238,23 +238,24 @@
LoweringContext Context;
};
-// TargetGlobalLowering is used for "lowering" global initializers,
-// including the internal constant pool. It is separated out from
-// TargetLowering because it does not require a Cfg.
-class TargetGlobalLowering {
- TargetGlobalLowering() = delete;
- TargetGlobalLowering(const TargetGlobalLowering &) = delete;
- TargetGlobalLowering &operator=(const TargetGlobalLowering &) = delete;
+// TargetDataLowering is used for "lowering" data including initializers
+// for global variables, and the internal constant pools. It is separated
+// out from TargetLowering because it does not require a Cfg.
+class TargetDataLowering {
+ TargetDataLowering() = delete;
+ TargetDataLowering(const TargetDataLowering &) = delete;
+ TargetDataLowering &operator=(const TargetDataLowering &) = delete;
public:
- static TargetGlobalLowering *createLowering(GlobalContext *Ctx);
- virtual ~TargetGlobalLowering();
+ static TargetDataLowering *createLowering(GlobalContext *Ctx);
+ virtual ~TargetDataLowering();
- virtual void lowerInit(const VariableDeclaration &Var) const = 0;
+ virtual void lowerGlobal(const VariableDeclaration &Var) const = 0;
+ virtual void lowerGlobalsELF(const VariableDeclarationList &Vars) const = 0;
virtual void lowerConstants(GlobalContext *Ctx) const = 0;
protected:
- TargetGlobalLowering(GlobalContext *Ctx) : Ctx(Ctx) {}
+ TargetDataLowering(GlobalContext *Ctx) : Ctx(Ctx) {}
GlobalContext *Ctx;
};
diff --git a/src/IceTargetLoweringX8632.cpp b/src/IceTargetLoweringX8632.cpp
index 2836865..8e57ba6 100644
--- a/src/IceTargetLoweringX8632.cpp
+++ b/src/IceTargetLoweringX8632.cpp
@@ -4560,25 +4560,19 @@
llvm_unreachable("undef value encountered by emitter.");
}
-TargetGlobalX8632::TargetGlobalX8632(GlobalContext *Ctx)
- : TargetGlobalLowering(Ctx) {}
+TargetDataX8632::TargetDataX8632(GlobalContext *Ctx)
+ : TargetDataLowering(Ctx) {}
-void TargetGlobalX8632::lowerInit(const VariableDeclaration &Var) const {
- // TODO(jvoung): handle this without text.
- if (Ctx->getFlags().UseELFWriter)
- return;
-
- Ostream &Str = Ctx->getStrEmit();
-
- const VariableDeclaration::InitializerListType &Initializers =
- Var.getInitializers();
-
+void TargetDataX8632::lowerGlobal(const VariableDeclaration &Var) const {
// If external and not initialized, this must be a cross test.
// Don't generate a declaration for such cases.
bool IsExternal = Var.isExternal() || Ctx->getFlags().DisableInternal;
if (IsExternal && !Var.hasInitializer())
return;
+ Ostream &Str = Ctx->getStrEmit();
+ const VariableDeclaration::InitializerListType &Initializers =
+ Var.getInitializers();
bool HasNonzeroInitializer = Var.hasNonzeroInitializer();
bool IsConstant = Var.getIsConstant();
uint32_t Align = Var.getAlignment();
@@ -4645,6 +4639,12 @@
Str << "\t.size\t" << MangledName << ", " << Size << "\n";
}
+void
+TargetDataX8632::lowerGlobalsELF(const VariableDeclarationList &Vars) const {
+ ELFObjectWriter *Writer = Ctx->getObjectWriter();
+ Writer->writeDataSection(Vars, llvm::ELF::R_386_32);
+}
+
template <typename T> struct PoolTypeConverter {};
template <> struct PoolTypeConverter<float> {
@@ -4672,7 +4672,7 @@
const char *PoolTypeConverter<double>::PrintfString = "0x%llx";
template <typename T>
-void TargetGlobalX8632::emitConstantPool(GlobalContext *Ctx) {
+void TargetDataX8632::emitConstantPool(GlobalContext *Ctx) {
// Note: Still used by emit IAS.
Ostream &Str = Ctx->getStrEmit();
Type Ty = T::Ty;
@@ -4701,7 +4701,7 @@
}
}
-void TargetGlobalX8632::lowerConstants(GlobalContext *Ctx) const {
+void TargetDataX8632::lowerConstants(GlobalContext *Ctx) const {
if (Ctx->getFlags().DisableTranslation)
return;
// No need to emit constants from the int pool since (for x86) they
diff --git a/src/IceTargetLoweringX8632.h b/src/IceTargetLoweringX8632.h
index 1ee3c1d..de0e925 100644
--- a/src/IceTargetLoweringX8632.h
+++ b/src/IceTargetLoweringX8632.h
@@ -488,24 +488,25 @@
~TargetX8632() override {}
};
-class TargetGlobalX8632 : public TargetGlobalLowering {
- TargetGlobalX8632() = delete;
- TargetGlobalX8632(const TargetGlobalX8632 &) = delete;
- TargetGlobalX8632 &operator=(const TargetGlobalX8632 &) = delete;
+class TargetDataX8632 : public TargetDataLowering {
+ TargetDataX8632() = delete;
+ TargetDataX8632(const TargetDataX8632 &) = delete;
+ TargetDataX8632 &operator=(const TargetDataX8632 &) = delete;
public:
- static TargetGlobalLowering *create(GlobalContext *Ctx) {
- return new TargetGlobalX8632(Ctx);
+ static TargetDataLowering *create(GlobalContext *Ctx) {
+ return new TargetDataX8632(Ctx);
}
- virtual void lowerInit(const VariableDeclaration &Var) const final;
- virtual void lowerConstants(GlobalContext *Ctx) const final;
+ void lowerGlobal(const VariableDeclaration &Var) const final;
+ void lowerGlobalsELF(const VariableDeclarationList &Vars) const final;
+ void lowerConstants(GlobalContext *Ctx) const final;
protected:
- TargetGlobalX8632(GlobalContext *Ctx);
+ TargetDataX8632(GlobalContext *Ctx);
private:
- ~TargetGlobalX8632() override {}
+ ~TargetDataX8632() override {}
template <typename T> static void emitConstantPool(GlobalContext *Ctx);
};
diff --git a/src/IceTimerTree.def b/src/IceTimerTree.def
index 3139a81..dba5ae7 100644
--- a/src/IceTimerTree.def
+++ b/src/IceTimerTree.def
@@ -26,6 +26,7 @@
X(doBranchOpt) \
X(doNopInsertion) \
X(emit) \
+ X(emitGlobalInitializers) \
X(genCode) \
X(genFrame) \
X(initUnhandled) \
diff --git a/src/IceTranslator.cpp b/src/IceTranslator.cpp
index 4198442..c05f58d 100644
--- a/src/IceTranslator.cpp
+++ b/src/IceTranslator.cpp
@@ -23,8 +23,7 @@
Translator::Translator(GlobalContext *Ctx, const ClFlags &Flags)
: Ctx(Ctx), Flags(Flags),
- GlobalLowering(TargetGlobalLowering::createLowering(Ctx)), ErrorStatus() {
-}
+ DataLowering(TargetDataLowering::createLowering(Ctx)), ErrorStatus() {}
Translator::~Translator() {}
@@ -63,7 +62,7 @@
void Translator::emitConstants() {
if (!getErrorStatus())
- GlobalLowering->lowerConstants(Ctx);
+ DataLowering->lowerConstants(Ctx);
}
void Translator::transferErrorCode() const {
@@ -71,19 +70,33 @@
Ctx->getErrorStatus()->assign(getErrorStatus().value());
}
-void Translator::lowerGlobals(
- const VariableDeclarationListType &VariableDeclarations) {
+void
+Translator::lowerGlobals(const VariableDeclarationList &VariableDeclarations) {
+ TimerMarker T(TimerStack::TT_emitGlobalInitializers, Ctx);
bool DisableTranslation = Ctx->getFlags().DisableTranslation;
const bool DumpGlobalVariables =
ALLOW_DUMP && Ctx->getVerbose() && Ctx->getFlags().VerboseFocusOn.empty();
- OstreamLocker L(Ctx);
- Ostream &Stream = Ctx->getStrDump();
- const IceString &TranslateOnly = Ctx->getFlags().TranslateOnly;
- for (const Ice::VariableDeclaration *Global : VariableDeclarations) {
- if (DumpGlobalVariables)
- Global->dump(getContext(), Stream);
- if (!DisableTranslation &&
- GlobalContext::matchSymbolName(Global->getName(), TranslateOnly))
- GlobalLowering->lowerInit(*Global);
+ if (Ctx->getFlags().UseELFWriter) {
+ // Dump all globals if requested, but don't interleave w/ emission.
+ if (DumpGlobalVariables) {
+ OstreamLocker L(Ctx);
+ Ostream &Stream = Ctx->getStrDump();
+ for (const Ice::VariableDeclaration *Global : VariableDeclarations) {
+ Global->dump(getContext(), Stream);
+ }
+ }
+ DataLowering->lowerGlobalsELF(VariableDeclarations);
+ } else {
+ const IceString &TranslateOnly = Ctx->getFlags().TranslateOnly;
+ OstreamLocker L(Ctx);
+ Ostream &Stream = Ctx->getStrDump();
+ for (const Ice::VariableDeclaration *Global : VariableDeclarations) {
+ // Interleave dump output w/ emit output.
+ if (DumpGlobalVariables)
+ Global->dump(getContext(), Stream);
+ if (!DisableTranslation &&
+ GlobalContext::matchSymbolName(Global->getName(), TranslateOnly))
+ DataLowering->lowerGlobal(*Global);
+ }
}
}
diff --git a/src/IceTranslator.h b/src/IceTranslator.h
index 630997b..cd5a8d6 100644
--- a/src/IceTranslator.h
+++ b/src/IceTranslator.h
@@ -34,9 +34,8 @@
Translator &operator=(const Translator &) = delete;
public:
- typedef std::vector<VariableDeclaration *> VariableDeclarationListType;
-
Translator(GlobalContext *Ctx, const ClFlags &Flags);
+
~Translator();
const ErrorCode &getErrorStatus() const { return ErrorStatus; }
@@ -57,7 +56,7 @@
/// Lowers the given list of global addresses to target. Generates
/// list of corresponding variable declarations.
- void lowerGlobals(const VariableDeclarationListType &VariableDeclarations);
+ void lowerGlobals(const VariableDeclarationList &VariableDeclarations);
/// Creates a name using the given prefix and corresponding index.
std::string createUnnamedName(const IceString &Prefix, SizeT Index);
@@ -71,7 +70,7 @@
protected:
GlobalContext *Ctx;
const ClFlags &Flags;
- std::unique_ptr<TargetGlobalLowering> GlobalLowering;
+ std::unique_ptr<TargetDataLowering> DataLowering;
// Exit status of the translation. False is successful. True otherwise.
ErrorCode ErrorStatus;
};
diff --git a/src/IceUtils.h b/src/IceUtils.h
index 35dd7f7..dc3a5ff 100644
--- a/src/IceUtils.h
+++ b/src/IceUtils.h
@@ -53,6 +53,14 @@
return ((X > 0 && Y > 0 && (X > std::numeric_limits<T>::max() - Y)) ||
(X < 0 && Y < 0 && (X < std::numeric_limits<T>::min() - Y)));
}
+
+ static inline uint64_t OffsetToAlignment(uint64_t Pos, uint64_t Align) {
+ assert(llvm::isPowerOf2_64(Align));
+ uint64_t Mod = Pos & (Align - 1);
+ if (Mod == 0)
+ return 0;
+ return Align - Mod;
+ }
};
// BoundedProducerConsumerQueue is a work queue that allows multiple
diff --git a/src/PNaClTranslator.cpp b/src/PNaClTranslator.cpp
index 80dccb1..893f912 100644
--- a/src/PNaClTranslator.cpp
+++ b/src/PNaClTranslator.cpp
@@ -351,7 +351,7 @@
}
/// Returns the list of parsed global variable declarations.
- const Ice::Translator::VariableDeclarationListType &getGlobalVariables() {
+ const Ice::VariableDeclarationList &getGlobalVariables() {
return VariableDeclarations;
}
@@ -376,7 +376,7 @@
// actually-defined function.
size_t NextDefiningFunctionID;
// The set of global variables.
- Ice::Translator::VariableDeclarationListType VariableDeclarations;
+ Ice::VariableDeclarationList VariableDeclarations;
// Relocatable constants associated with global declarations.
std::vector<Ice::Constant *> ValueIDConstants;
// Error recovery value to use when getFuncSigTypeByID fails.
diff --git a/src/assembler_ia32.cpp b/src/assembler_ia32.cpp
index 88ad7ef..d4fff33 100644
--- a/src/assembler_ia32.cpp
+++ b/src/assembler_ia32.cpp
@@ -43,19 +43,13 @@
}
void AssemblerX86::alignFunction() {
- intptr_t Pos = buffer_.GetPosition();
SizeT Align = 1 << getBundleAlignLog2Bytes();
- intptr_t Mod = Pos & (Align - 1);
- if (Mod == 0) {
- return;
- }
- SizeT BytesNeeded = Align - Mod;
+ SizeT BytesNeeded = Utils::OffsetToAlignment(buffer_.GetPosition(), Align);
const SizeT HltSize = 1;
while (BytesNeeded > 0) {
hlt();
BytesNeeded -= HltSize;
}
- assert((buffer_.GetPosition() & (Align - 1)) == 0);
}
Label *AssemblerX86::GetOrCreateLabel(SizeT Number, LabelVector &Labels) {