[llvm-commits] [llvm] r75828 - in /llvm/trunk/lib: CodeGen/ELF.h CodeGen/ELFCodeEmitter.cpp CodeGen/ELFWriter.cpp CodeGen/ELFWriter.h Target/X86/X86ELFWriterInfo.cpp
Bruno Cardoso Lopes
bruno.cardoso at gmail.com
Wed Jul 15 13:49:10 PDT 2009
Author: bruno
Date: Wed Jul 15 15:49:10 2009
New Revision: 75828
URL: http://llvm.org/viewvc/llvm-project?rev=75828&view=rev
Log:
use std::vector instead of std::list for both Section and Symbol lists because
we care more about random access than insertion/deletion of elements.
Modified:
llvm/trunk/lib/CodeGen/ELF.h
llvm/trunk/lib/CodeGen/ELFCodeEmitter.cpp
llvm/trunk/lib/CodeGen/ELFWriter.cpp
llvm/trunk/lib/CodeGen/ELFWriter.h
llvm/trunk/lib/Target/X86/X86ELFWriterInfo.cpp
Modified: llvm/trunk/lib/CodeGen/ELF.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/ELF.h?rev=75828&r1=75827&r2=75828&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/ELF.h (original)
+++ llvm/trunk/lib/CodeGen/ELF.h Wed Jul 15 15:49:10 2009
@@ -52,6 +52,70 @@
EV_CURRENT = 1
};
+ /// ELFSym - This struct contains information about each symbol that is
+ /// added to logical symbol table for the module. This is eventually
+ /// turned into a real symbol table in the file.
+ struct ELFSym {
+ // The global value this symbol matches. This should be null if the symbol
+ // is not a global value.
+ const GlobalValue *GV;
+
+ // ELF specific fields
+ unsigned NameIdx; // Index in .strtab of name, once emitted.
+ uint64_t Value;
+ unsigned Size;
+ uint8_t Info;
+ uint8_t Other;
+ unsigned short SectionIdx;
+
+ // Symbol index into the Symbol table
+ unsigned SymTabIdx;
+
+ enum {
+ STB_LOCAL = 0,
+ STB_GLOBAL = 1,
+ STB_WEAK = 2
+ };
+
+ enum {
+ STT_NOTYPE = 0,
+ STT_OBJECT = 1,
+ STT_FUNC = 2,
+ STT_SECTION = 3,
+ STT_FILE = 4
+ };
+
+ enum {
+ STV_DEFAULT = 0, // Visibility is specified by binding type
+ STV_INTERNAL = 1, // Defined by processor supplements
+ STV_HIDDEN = 2, // Not visible to other components
+ STV_PROTECTED = 3 // Visible in other components but not preemptable
+ };
+
+ ELFSym(const GlobalValue *gv) : GV(gv), NameIdx(0), Value(0),
+ Size(0), Info(0), Other(STV_DEFAULT),
+ SectionIdx(0), SymTabIdx(0) {}
+
+ unsigned getBind() const { return (Info >> 4) & 0xf; }
+ unsigned getType() const { return Info & 0xf; }
+ bool isLocalBind() const { return getBind() == STB_LOCAL; }
+
+ void setBind(unsigned X) {
+ assert(X == (X & 0xF) && "Bind value out of range!");
+ Info = (Info & 0x0F) | (X << 4);
+ }
+
+ void setType(unsigned X) {
+ assert(X == (X & 0xF) && "Type value out of range!");
+ Info = (Info & 0xF0) | X;
+ }
+
+ void setVisibility(unsigned V) {
+ assert(V == (V & 0x3) && "Visibility value out of range!");
+ Other = V;
+ }
+ };
+
/// ELFSection - This struct contains information about each section that is
/// emitted to the file. This is eventually turned into the section header
/// table at the end of the file.
@@ -117,73 +181,12 @@
/// SectionIdx - The number of the section in the Section Table.
unsigned short SectionIdx;
+ /// Sym - The symbol to represent this section if it has one.
+ ELFSym *Sym;
+
ELFSection(const std::string &name, bool isLittleEndian, bool is64Bit)
: BinaryObject(name, isLittleEndian, is64Bit), Type(0), Flags(0), Addr(0),
- Offset(0), Size(0), Link(0), Info(0), Align(0), EntSize(0) {}
- };
-
- /// ELFSym - This struct contains information about each symbol that is
- /// added to logical symbol table for the module. This is eventually
- /// turned into a real symbol table in the file.
- struct ELFSym {
- // The global value this symbol matches. This should be null if the symbol
- // is not a global value.
- const GlobalValue *GV;
-
- // ELF specific fields
- unsigned NameIdx; // Index in .strtab of name, once emitted.
- uint64_t Value;
- unsigned Size;
- uint8_t Info;
- uint8_t Other;
- unsigned short SectionIdx;
-
- // Symbol index into the Symbol table
- unsigned SymTabIdx;
-
- enum {
- STB_LOCAL = 0,
- STB_GLOBAL = 1,
- STB_WEAK = 2
- };
-
- enum {
- STT_NOTYPE = 0,
- STT_OBJECT = 1,
- STT_FUNC = 2,
- STT_SECTION = 3,
- STT_FILE = 4
- };
-
- enum {
- STV_DEFAULT = 0, // Visibility is specified by binding type
- STV_INTERNAL = 1, // Defined by processor supplements
- STV_HIDDEN = 2, // Not visible to other components
- STV_PROTECTED = 3 // Visible in other components but not preemptable
- };
-
- ELFSym(const GlobalValue *gv) : GV(gv), NameIdx(0), Value(0),
- Size(0), Info(0), Other(STV_DEFAULT),
- SectionIdx(ELFSection::SHN_UNDEF),
- SymTabIdx(0) {}
-
- unsigned getBind() { return (Info >> 4) & 0xf; }
- unsigned getType() { return Info & 0xf; }
-
- void setBind(unsigned X) {
- assert(X == (X & 0xF) && "Bind value out of range!");
- Info = (Info & 0x0F) | (X << 4);
- }
-
- void setType(unsigned X) {
- assert(X == (X & 0xF) && "Type value out of range!");
- Info = (Info & 0xF0) | X;
- }
-
- void setVisibility(unsigned V) {
- assert(V == (V & 0x3) && "Type value out of range!");
- Other = V;
- }
+ Offset(0), Size(0), Link(0), Info(0), Align(0), EntSize(0), Sym(0) {}
};
/// ELFRelocation - This class contains all the information necessary to
Modified: llvm/trunk/lib/CodeGen/ELFCodeEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/ELFCodeEmitter.cpp?rev=75828&r1=75827&r2=75828&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/ELFCodeEmitter.cpp (original)
+++ llvm/trunk/lib/CodeGen/ELFCodeEmitter.cpp Wed Jul 15 15:49:10 2009
@@ -60,23 +60,18 @@
bool ELFCodeEmitter::finishFunction(MachineFunction &MF) {
// Add a symbol to represent the function.
const Function *F = MF.getFunction();
- ELFSym FnSym(F);
- FnSym.setType(ELFSym::STT_FUNC);
- FnSym.setBind(EW.getGlobalELFBinding(F));
- FnSym.setVisibility(EW.getGlobalELFVisibility(F));
- FnSym.SectionIdx = ES->SectionIdx;
- FnSym.Size = ES->getCurrentPCOffset()-FnStartOff;
+ ELFSym *FnSym = new ELFSym(F);
+ FnSym->setType(ELFSym::STT_FUNC);
+ FnSym->setBind(EW.getGlobalELFBinding(F));
+ FnSym->setVisibility(EW.getGlobalELFVisibility(F));
+ FnSym->SectionIdx = ES->SectionIdx;
+ FnSym->Size = ES->getCurrentPCOffset()-FnStartOff;
// Offset from start of Section
- FnSym.Value = FnStartOff;
+ FnSym->Value = FnStartOff;
- // Locals should go on the symbol list front
- if (!F->hasPrivateLinkage()) {
- if (FnSym.getBind() == ELFSym::STB_LOCAL)
- EW.SymbolList.push_front(FnSym);
- else
- EW.SymbolList.push_back(FnSym);
- }
+ if (!F->hasPrivateLinkage())
+ EW.SymbolList.push_back(FnSym);
// Emit constant pool to appropriate section(s)
emitConstantPool(MF.getConstantPool());
Modified: llvm/trunk/lib/CodeGen/ELFWriter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/ELFWriter.cpp?rev=75828&r1=75827&r2=75828&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/ELFWriter.cpp (original)
+++ llvm/trunk/lib/CodeGen/ELFWriter.cpp Wed Jul 15 15:49:10 2009
@@ -235,13 +235,13 @@
// Handle ELF Bind, Visibility and Type for the current symbol
unsigned SymBind = getGlobalELFBinding(GV);
- ELFSym GblSym(GV);
- GblSym.setBind(SymBind);
- GblSym.setVisibility(getGlobalELFVisibility(GV));
- GblSym.setType(getGlobalELFType(GV));
+ ELFSym *GblSym = new ELFSym(GV);
+ GblSym->setBind(SymBind);
+ GblSym->setVisibility(getGlobalELFVisibility(GV));
+ GblSym->setType(getGlobalELFType(GV));
if (isELFUndefSym(GV)) {
- GblSym.SectionIdx = ELFSection::SHN_UNDEF;
+ GblSym->SectionIdx = ELFSection::SHN_UNDEF;
} else {
assert(isa<GlobalVariable>(GV) && "GV not a global variable!");
const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
@@ -254,41 +254,41 @@
const TargetData *TD = TM.getTargetData();
unsigned Align = TD->getPreferredAlignment(GVar);
unsigned Size = TD->getTypeAllocSize(GVar->getInitializer()->getType());
- GblSym.Size = Size;
+ GblSym->Size = Size;
if (isELFCommonSym(GV)) {
- GblSym.SectionIdx = ELFSection::SHN_COMMON;
+ GblSym->SectionIdx = ELFSection::SHN_COMMON;
getSection(S->getName(), ELFSection::SHT_NOBITS, SectionFlags, 1);
// A new linkonce section is created for each global in the
// common section, the default alignment is 1 and the symbol
// value contains its alignment.
- GblSym.Value = Align;
+ GblSym->Value = Align;
} else if (isELFBssSym(GV)) {
ELFSection &ES =
getSection(S->getName(), ELFSection::SHT_NOBITS, SectionFlags);
- GblSym.SectionIdx = ES.SectionIdx;
+ GblSym->SectionIdx = ES.SectionIdx;
// Update the size with alignment and the next object can
// start in the right offset in the section
if (Align) ES.Size = (ES.Size + Align-1) & ~(Align-1);
ES.Align = std::max(ES.Align, Align);
- // GblSym.Value should contain the virtual offset inside the section.
+ // GblSym->Value should contain the virtual offset inside the section.
// Virtual because the BSS space is not allocated on ELF objects
- GblSym.Value = ES.Size;
+ GblSym->Value = ES.Size;
ES.Size += Size;
} else if (isELFDataSym(GV)) {
ELFSection &ES =
getSection(S->getName(), ELFSection::SHT_PROGBITS, SectionFlags);
- GblSym.SectionIdx = ES.SectionIdx;
+ GblSym->SectionIdx = ES.SectionIdx;
- // GblSym.Value should contain the symbol offset inside the section,
+ // GblSym->Value should contain the symbol offset inside the section,
// and all symbols should start on their required alignment boundary
ES.Align = std::max(ES.Align, Align);
- GblSym.Value = (ES.size() + (Align-1)) & (-Align);
+ GblSym->Value = (ES.size() + (Align-1)) & (-Align);
ES.emitAlignment(ES.Align);
// Emit the global to the data section 'ES'
@@ -296,13 +296,8 @@
}
}
- // Local symbols should come first on the symbol table.
- if (!GV->hasPrivateLinkage()) {
- if (SymBind == ELFSym::STB_LOCAL)
- SymbolList.push_front(GblSym);
- else
- SymbolList.push_back(GblSym);
- }
+ if (!GV->hasPrivateLinkage())
+ SymbolList.push_back(GblSym);
}
void ELFWriter::EmitGlobalConstantStruct(const ConstantStruct *CVS,
@@ -419,23 +414,17 @@
if (TAI->getNonexecutableStackDirective())
getNonExecStackSection();
- // Emit a symbol for each section created until now
- for (std::map<std::string, ELFSection*>::iterator I = SectionLookup.begin(),
- E = SectionLookup.end(); I != E; ++I) {
- ELFSection *ES = I->second;
-
- // Skip null section
- if (ES->SectionIdx == 0) continue;
-
- ELFSym SectionSym(0);
- SectionSym.SectionIdx = ES->SectionIdx;
- SectionSym.Size = 0;
- SectionSym.setBind(ELFSym::STB_LOCAL);
- SectionSym.setType(ELFSym::STT_SECTION);
- SectionSym.setVisibility(ELFSym::STV_DEFAULT);
-
- // Local symbols go in the list front
- SymbolList.push_front(SectionSym);
+ // Emit a symbol for each section created until now, skip null section
+ for (unsigned i = 1, e = SectionList.size(); i < e; ++i) {
+ ELFSection &ES = *SectionList[i];
+ ELFSym *SectionSym = new ELFSym(0);
+ SectionSym->SectionIdx = ES.SectionIdx;
+ SectionSym->Size = 0;
+ SectionSym->setBind(ELFSym::STB_LOCAL);
+ SectionSym->setType(ELFSym::STT_SECTION);
+ SectionSym->setVisibility(ELFSym::STV_DEFAULT);
+ SymbolList.push_back(SectionSym);
+ ES.Sym = SymbolList.back();
}
// Emit string table
@@ -454,6 +443,7 @@
OutputSectionsAndSectionTable();
// We are done with the abstract symbols.
+ SymbolList.clear();
SectionList.clear();
NumSections = 0;
@@ -466,26 +456,26 @@
void ELFWriter::EmitRelocations() {
// Create Relocation sections for each section which needs it.
- for (std::list<ELFSection>::iterator I = SectionList.begin(),
- E = SectionList.end(); I != E; ++I) {
+ for (unsigned i=0, e=SectionList.size(); i < e; ++i) {
+ ELFSection &S = *SectionList[i];
// This section does not have relocations
- if (!I->hasRelocations()) continue;
+ if (!S.hasRelocations()) continue;
- // Get the relocation section for section 'I'
+ // Get the relocation section for section 'S'
bool HasRelA = TEW->hasRelocationAddend();
- ELFSection &RelSec = getRelocSection(I->getName(), HasRelA,
+ ELFSection &RelSec = getRelocSection(S.getName(), HasRelA,
TEW->getPrefELFAlignment());
// 'Link' - Section hdr idx of the associated symbol table
// 'Info' - Section hdr idx of the section to which the relocation applies
ELFSection &SymTab = getSymbolTableSection();
RelSec.Link = SymTab.SectionIdx;
- RelSec.Info = I->SectionIdx;
+ RelSec.Info = S.SectionIdx;
RelSec.EntSize = TEW->getRelocationEntrySize();
// Get the relocations from Section
- std::vector<MachineRelocation> Relos = I->getRelocations();
+ std::vector<MachineRelocation> Relos = S.getRelocations();
for (std::vector<MachineRelocation>::iterator MRI = Relos.begin(),
MRE = Relos.end(); MRI != MRE; ++MRI) {
MachineRelocation &MR = *MRI;
@@ -510,15 +500,10 @@
SymIdx = GblSymLookup[G];
Addend = TEW->getAddendForRelTy(RelType);
} else {
+ // Get the symbol index for the section symbol referenced
+ // by the relocation
unsigned SectionIdx = MR.getConstantVal();
- // TODO: use a map for this.
- for (std::list<ELFSym>::iterator I = SymbolList.begin(),
- E = SymbolList.end(); I != E; ++I)
- if ((SectionIdx == I->SectionIdx) &&
- (I->getType() == ELFSym::STT_SECTION)) {
- SymIdx = I->SymTabIdx;
- break;
- }
+ SymIdx = SectionList[SectionIdx]->Sym->SymTabIdx;
Addend = (uint64_t)MR.getResultPointer();
}
@@ -596,17 +581,17 @@
// Walk on the symbol list and write symbol names into the
// string table.
unsigned Index = 1;
- for (std::list<ELFSym>::iterator I = SymbolList.begin(),
- E = SymbolList.end(); I != E; ++I) {
+ for (unsigned i = 0, e = SymbolList.size(); i < e; ++i) {
+ ELFSym &Sym = *SymbolList[i];
// Use the name mangler to uniquify the LLVM symbol.
std::string Name;
- if (I->GV) Name.append(Mang->getMangledName(I->GV));
+ if (Sym.GV) Name.append(Mang->getMangledName(Sym.GV));
if (Name.empty()) {
- I->NameIdx = 0;
+ Sym.NameIdx = 0;
} else {
- I->NameIdx = Index;
+ Sym.NameIdx = Index;
StrTab.emitString(Name);
// Keep track of the number of bytes emitted to this section.
@@ -617,11 +602,38 @@
StrTab.Size = Index;
}
+// SortSymbols - On the symbol table local symbols must come before
+// all other symbols with non-local bindings. The return value is
+// the position of the first non local symbol.
+unsigned ELFWriter::SortSymbols() {
+ unsigned FirstNonLocalSymbol, i, e;
+ std::vector<ELFSym*> LocalSyms, OtherSyms;
+
+ for (i = 0, e = SymbolList.size(); i < e; ++i) {
+ if (SymbolList[i]->isLocalBind())
+ LocalSyms.push_back(SymbolList[i]);
+ else
+ OtherSyms.push_back(SymbolList[i]);
+ }
+ SymbolList.clear();
+ FirstNonLocalSymbol = LocalSyms.size();
+
+ for (i = 0; i < FirstNonLocalSymbol; ++i)
+ SymbolList.push_back(LocalSyms[i]);
+
+ for (i = 0, e = OtherSyms.size(); i < e; ++i)
+ SymbolList.push_back(OtherSyms[i]);
+
+ LocalSyms.clear();
+ OtherSyms.clear();
+
+ return FirstNonLocalSymbol;
+}
+
/// EmitSymbolTable - Emit the symbol table itself.
void ELFWriter::EmitSymbolTable() {
if (!SymbolList.size()) return; // Empty symbol table.
- unsigned FirstNonLocalSymbol = 1;
// Now that we have emitted the string table and know the offset into the
// string table of each symbol, emit the symbol table itself.
ELFSection &SymTab = getSymbolTableSection();
@@ -634,29 +646,26 @@
SymTab.EntSize = TEW->getSymTabEntrySize();
// The first entry in the symtab is the null symbol
- ELFSym NullSym = ELFSym(0);
- EmitSymbol(SymTab, NullSym);
+ SymbolList.insert(SymbolList.begin(), new ELFSym(0));
- // Emit all the symbols to the symbol table. Skip the null
- // symbol, cause it's emitted already
- unsigned Index = 1;
- for (std::list<ELFSym>::iterator I = SymbolList.begin(),
- E = SymbolList.end(); I != E; ++I, ++Index) {
- // Keep track of the first non-local symbol
- if (I->getBind() == ELFSym::STB_LOCAL)
- FirstNonLocalSymbol++;
+ // Reorder the symbol table with local symbols first!
+ unsigned FirstNonLocalSymbol = SortSymbols();
+
+ // Emit all the symbols to the symbol table.
+ for (unsigned i = 0, e = SymbolList.size(); i < e; ++i) {
+ ELFSym &Sym = *SymbolList[i];
// Emit symbol to the symbol table
- EmitSymbol(SymTab, *I);
+ EmitSymbol(SymTab, Sym);
// Record the symbol table index for each global value
- if (I->GV)
- GblSymLookup[I->GV] = Index;
+ if (Sym.GV) GblSymLookup[Sym.GV] = i;
// Keep track on the symbol index into the symbol table
- I->SymTabIdx = Index;
+ Sym.SymTabIdx = i;
}
+ // One greater than the symbol table index of the last local symbol
SymTab.Info = FirstNonLocalSymbol;
SymTab.Size = SymTab.size();
}
@@ -676,15 +685,14 @@
// the string table.
unsigned Index = 0;
- for (std::list<ELFSection>::iterator I = SectionList.begin(),
- E = SectionList.end(); I != E; ++I) {
+ for (unsigned i=0, e=SectionList.size(); i < e; ++i) {
// Set the index into the table. Note if we have lots of entries with
// common suffixes, we could memoize them here if we cared.
- I->NameIdx = Index;
- SHStrTab.emitString(I->getName());
+ SectionList[i]->NameIdx = Index;
+ SHStrTab.emitString(SectionList[i]->getName());
// Keep track of the number of bytes emitted to this section.
- Index += I->getName().size()+1;
+ Index += SectionList[i]->getName().size()+1;
}
// Set the size of .shstrtab now that we know what it is.
@@ -699,29 +707,24 @@
// Pass #1: Compute the file offset for each section.
size_t FileOff = ElfHdr.size(); // File header first.
- // Adjust alignment of all section if needed.
- for (std::list<ELFSection>::iterator I = SectionList.begin(),
- E = SectionList.end(); I != E; ++I) {
-
- // Section idx 0 has 0 offset
- if (!I->SectionIdx)
- continue;
-
- if (!I->size()) {
- I->Offset = FileOff;
+ // Adjust alignment of all section if needed, skip the null section.
+ for (unsigned i=1, e=SectionList.size(); i < e; ++i) {
+ ELFSection &ES = *SectionList[i];
+ if (!ES.size()) {
+ ES.Offset = FileOff;
continue;
}
// Update Section size
- if (!I->Size)
- I->Size = I->size();
+ if (!ES.Size)
+ ES.Size = ES.size();
// Align FileOff to whatever the alignment restrictions of the section are.
- if (I->Align)
- FileOff = (FileOff+I->Align-1) & ~(I->Align-1);
+ if (ES.Align)
+ FileOff = (FileOff+ES.Align-1) & ~(ES.Align-1);
- I->Offset = FileOff;
- FileOff += I->Size;
+ ES.Offset = FileOff;
+ FileOff += ES.Size;
}
// Align Section Header.
@@ -745,8 +748,8 @@
BinaryObject SHdrTable(isLittleEndian, is64Bit);
// Emit all of sections to the file and build the section header table.
- while (!SectionList.empty()) {
- ELFSection &S = *SectionList.begin();
+ for (unsigned i=0, e=SectionList.size(); i < e; ++i) {
+ ELFSection &S = *SectionList[i];
DOUT << "SectionIdx: " << S.SectionIdx << ", Name: " << S.getName()
<< ", Size: " << S.Size << ", Offset: " << S.Offset
<< ", SectionData Size: " << S.size() << "\n";
@@ -763,7 +766,6 @@
}
EmitSectionHeader(SHdrTable, S);
- SectionList.pop_front();
}
// Align output for the section table.
Modified: llvm/trunk/lib/CodeGen/ELFWriter.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/ELFWriter.h?rev=75828&r1=75827&r2=75828&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/ELFWriter.h (original)
+++ llvm/trunk/lib/CodeGen/ELFWriter.h Wed Jul 15 15:49:10 2009
@@ -16,7 +16,6 @@
#include "llvm/ADT/SetVector.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
-#include <list>
#include <map>
namespace llvm {
@@ -95,13 +94,13 @@
BinaryObject ElfHdr;
/// SectionList - This is the list of sections that we have emitted to the
- /// file. Once the file has been completely built, the section header table
+ /// file. Once the file has been completely built, the section header table
/// is constructed from this info.
- std::list<ELFSection> SectionList;
+ std::vector<ELFSection*> SectionList;
unsigned NumSections; // Always = SectionList.size()
/// SectionLookup - This is a mapping from section name to section number in
- /// the SectionList.
+ /// the SectionList. Used to quickly gather the Section Index from TAI names
std::map<std::string, ELFSection*> SectionLookup;
/// GblSymLookup - This is a mapping from global value to a symbol index
@@ -109,17 +108,18 @@
/// must be quickly mapped to a symbol table index
std::map<const GlobalValue*, uint32_t> GblSymLookup;
- /// SymbolList - This is the list of symbols emitted to the symbol table
- /// Local symbols go to the front and Globals to the back.
- std::list<ELFSym> SymbolList;
+ /// SymbolList - This is the list of symbols emitted to the symbol table.
+ /// When the SymbolList is finally built, local symbols must be placed in
+ /// the beginning while non-locals at the end.
+ std::vector<ELFSym*> SymbolList;
/// PendingGlobals - List of externally defined symbols that we have been
/// asked to emit, but have not seen a reference to. When a reference
/// is seen, the symbol will move from this list to the SymbolList.
SetVector<GlobalValue*> PendingGlobals;
- // Remove tab from section name prefix. This is necessary becase TAI
- // sometimes return a section name prefixed with a "\t" char. This is
+ // Remove tab from section name prefix. This is necessary becase TAI
+ // sometimes return a section name prefixed with elf unused chars. This is
// a little bit dirty. FIXME: find a better approach, maybe add more
// methods to TAI to get the clean name?
void fixNameForSection(std::string &Name) {
@@ -140,14 +140,14 @@
/// section if one does not already exist.
ELFSection &getSection(const std::string &Name, unsigned Type,
unsigned Flags = 0, unsigned Align = 0) {
- std::string SectionName(Name);
- fixNameForSection(SectionName);
+ std::string SName(Name);
+ fixNameForSection(SName);
- ELFSection *&SN = SectionLookup[SectionName];
+ ELFSection *&SN = SectionLookup[SName];
if (SN) return *SN;
- SectionList.push_back(ELFSection(SectionName, isLittleEndian, is64Bit));
- SN = &SectionList.back();
+ SectionList.push_back(new ELFSection(SName, isLittleEndian, is64Bit));
+ SN = SectionList.back();
SN->SectionIdx = NumSections++;
SN->Type = Type;
SN->Flags = Flags;
@@ -245,6 +245,7 @@
void EmitSymbolTable();
void EmitStringTable();
void OutputSectionsAndSectionTable();
+ unsigned SortSymbols();
};
}
Modified: llvm/trunk/lib/Target/X86/X86ELFWriterInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/X86ELFWriterInfo.cpp?rev=75828&r1=75827&r2=75828&view=diff
==============================================================================
--- llvm/trunk/lib/Target/X86/X86ELFWriterInfo.cpp (original)
+++ llvm/trunk/lib/Target/X86/X86ELFWriterInfo.cpp Wed Jul 15 15:49:10 2009
@@ -65,6 +65,8 @@
switch(RelTy) {
case R_X86_64_PC32: return -4;
break;
+ case R_X86_64_32: return 0;
+ break;
default:
llvm_unreachable("unknown x86 relocation type");
}
More information about the llvm-commits
mailing list