6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-08-08 19:25:47 +00:00
Code Issues Projects Releases Wiki Activity

MC-COFF: Add support for default-null weak externals.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@116666 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Michael J. Spencer
2010-10-16 08:25:57 +00:00
parent 84ac4d5a2a
commit 4cee2890a6
4 changed files with 119 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/Support/COFF.h
View File

@@ -69,7 +69,7 @@ namespace COFF {
SF_ClassMask = 0x00FF0000, SF_ClassMask = 0x00FF0000,
SF_ClassShift = 16, SF_ClassShift = 16,
SF_WeakReference = 0x01000000 SF_WeakExternal = 0x01000000
}; };
enum SymbolSectionNumber { enum SymbolSectionNumber {

112
lib/MC/WinCOFFObjectWriter.cpp
View File

@@ -125,11 +125,8 @@ public:
typedef std::vector<COFFSymbol*> symbols; typedef std::vector<COFFSymbol*> symbols;
typedef std::vector<COFFSection*> sections; typedef std::vector<COFFSection*> sections;
typedef StringMap<COFFSymbol *> name_symbol_map; typedef DenseMap<MCSymbol const *, COFFSymbol *> symbol_map;
typedef StringMap<COFFSection *> name_section_map; typedef DenseMap<MCSection const *, COFFSection *> section_map;
typedef DenseMap<MCSymbolData const *, COFFSymbol *> symbol_map;
typedef DenseMap<MCSectionData const *, COFFSection *> section_map;
// Root level file contents. // Root level file contents.
bool Is64Bit; bool Is64Bit;
@@ -145,8 +142,9 @@ public:
WinCOFFObjectWriter(raw_ostream &OS, bool is64Bit); WinCOFFObjectWriter(raw_ostream &OS, bool is64Bit);
~WinCOFFObjectWriter(); ~WinCOFFObjectWriter();
COFFSymbol *createSymbol(llvm::StringRef Name); COFFSymbol *createSymbol(StringRef Name);
COFFSection *createSection(llvm::StringRef Name); COFFSymbol *GetOrCreateCOFFSymbol(const MCSymbol * Symbol);
COFFSection *createSection(StringRef Name);
template <typename object_t, typename list_t> template <typename object_t, typename list_t>
object_t *createCOFFEntity(llvm::StringRef Name, list_t &List); object_t *createCOFFEntity(llvm::StringRef Name, list_t &List);
@@ -336,10 +334,20 @@ WinCOFFObjectWriter::~WinCOFFObjectWriter() {
delete *I; delete *I;
} }
COFFSymbol *WinCOFFObjectWriter::createSymbol(llvm::StringRef Name) { COFFSymbol *WinCOFFObjectWriter::createSymbol(StringRef Name) {
return createCOFFEntity<COFFSymbol>(Name, Symbols); return createCOFFEntity<COFFSymbol>(Name, Symbols);
} }
COFFSymbol *WinCOFFObjectWriter::GetOrCreateCOFFSymbol(const MCSymbol * Symbol){
symbol_map::iterator i = SymbolMap.find(Symbol);
if (i != SymbolMap.end())
return i->second;
COFFSymbol *RetSymbol
= createCOFFEntity<COFFSymbol>(Symbol->getName(), Symbols);
SymbolMap[Symbol] = RetSymbol;
return RetSymbol;
}
COFFSection *WinCOFFObjectWriter::createSection(llvm::StringRef Name) { COFFSection *WinCOFFObjectWriter::createSection(llvm::StringRef Name) {
return createCOFFEntity<COFFSection>(Name, Sections); return createCOFFEntity<COFFSection>(Name, Sections);
} }
@@ -402,20 +410,53 @@ void WinCOFFObjectWriter::DefineSection(MCSectionData const &SectionData) {
// Bind internal COFF section to MC section. // Bind internal COFF section to MC section.
coff_section->MCData = &SectionData; coff_section->MCData = &SectionData;
SectionMap[&SectionData] = coff_section; SectionMap[&SectionData.getSection()] = coff_section;
} }
/// This function takes a section data object from the assembler /// This function takes a section data object from the assembler
/// and creates the associated COFF symbol staging object. /// and creates the associated COFF symbol staging object.
void WinCOFFObjectWriter::DefineSymbol(MCSymbolData const &SymbolData, void WinCOFFObjectWriter::DefineSymbol(MCSymbolData const &SymbolData,
MCAssembler &Assembler) { MCAssembler &Assembler) {
assert(!SymbolData.getSymbol().isVariable() COFFSymbol *coff_symbol = GetOrCreateCOFFSymbol(&SymbolData.getSymbol());
&& "Cannot define a symbol that is a variable!");
COFFSymbol *coff_symbol = createSymbol(SymbolData.getSymbol().getName());
coff_symbol->Data.Type = (SymbolData.getFlags() & 0x0000FFFF) >> 0; coff_symbol->Data.Type = (SymbolData.getFlags() & 0x0000FFFF) >> 0;
coff_symbol->Data.StorageClass = (SymbolData.getFlags() & 0x00FF0000) >> 16; coff_symbol->Data.StorageClass = (SymbolData.getFlags() & 0x00FF0000) >> 16;
if (SymbolData.getFlags() & COFF::SF_WeakExternal) {
coff_symbol->Data.StorageClass = COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL;
if (SymbolData.getSymbol().isVariable()) {
coff_symbol->Data.StorageClass = COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL;
const MCExpr *Value = SymbolData.getSymbol().getVariableValue();
// FIXME: This assert message isn't very good.
assert(Value->getKind() == MCExpr::SymbolRef &&
"Value must be a SymbolRef!");
const MCSymbolRefExpr *SymbolRef =
static_cast<const MCSymbolRefExpr *>(Value);
coff_symbol->Other = GetOrCreateCOFFSymbol(&SymbolRef->getSymbol());
} else {
std::string WeakName = std::string(".weak.")
+ SymbolData.getSymbol().getName().str()
+ ".default";
COFFSymbol *WeakDefault = createSymbol(WeakName);
WeakDefault->Data.SectionNumber = COFF::IMAGE_SYM_ABSOLUTE;
WeakDefault->Data.StorageClass = COFF::IMAGE_SYM_CLASS_EXTERNAL;
WeakDefault->Data.Type = 0;
WeakDefault->Data.Value = 0;
coff_symbol->Other = WeakDefault;
}
// Setup the Weak External auxiliary symbol.
coff_symbol->Aux.resize(1);
memset(&coff_symbol->Aux[0], 0, sizeof(coff_symbol->Aux[0]));
coff_symbol->Aux[0].AuxType = ATWeakExternal;
coff_symbol->Aux[0].Aux.WeakExternal.TagIndex = 0;
coff_symbol->Aux[0].Aux.WeakExternal.Characteristics =
COFF::IMAGE_WEAK_EXTERN_SEARCH_LIBRARY;
}
// If no storage class was specified in the streamer, define it here. // If no storage class was specified in the streamer, define it here.
if (coff_symbol->Data.StorageClass == 0) { if (coff_symbol->Data.StorageClass == 0) {
bool external = SymbolData.isExternal() || (SymbolData.Fragment == NULL); bool external = SymbolData.isExternal() || (SymbolData.Fragment == NULL);
@@ -424,42 +465,13 @@ void WinCOFFObjectWriter::DefineSymbol(MCSymbolData const &SymbolData,
external ? COFF::IMAGE_SYM_CLASS_EXTERNAL : COFF::IMAGE_SYM_CLASS_STATIC; external ? COFF::IMAGE_SYM_CLASS_EXTERNAL : COFF::IMAGE_SYM_CLASS_STATIC;
} }
if (SymbolData.getFlags() & COFF::SF_WeakReference) {
coff_symbol->Data.StorageClass = COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL;
const MCExpr *Value = SymbolData.getSymbol().getVariableValue();
// FIXME: This assert message isn't very good.
assert(Value->getKind() == MCExpr::SymbolRef &&
"Value must be a SymbolRef!");
const MCSymbolRefExpr *SymbolRef =
static_cast<const MCSymbolRefExpr *>(Value);
const MCSymbolData &OtherSymbolData =
Assembler.getSymbolData(SymbolRef->getSymbol());
// FIXME: This assert message isn't very good.
assert(SymbolMap.find(&OtherSymbolData) != SymbolMap.end() &&
"OtherSymbolData must be in the symbol map!");
coff_symbol->Other = SymbolMap[&OtherSymbolData];
// Setup the Weak External auxiliary symbol.
coff_symbol->Aux.resize(1);
memset(&coff_symbol->Aux[0], 0, sizeof(coff_symbol->Aux[0]));
coff_symbol->Aux[0].AuxType = ATWeakExternal;
coff_symbol->Aux[0].Aux.WeakExternal.TagIndex = 0;
coff_symbol->Aux[0].Aux.WeakExternal.Characteristics =
COFF::IMAGE_WEAK_EXTERN_SEARCH_LIBRARY;
}
if (SymbolData.Fragment != NULL) if (SymbolData.Fragment != NULL)
coff_symbol->Section = SectionMap[SymbolData.Fragment->getParent()]; coff_symbol->Section =
SectionMap[&SymbolData.Fragment->getParent()->getSection()];
// Bind internal COFF symbol to MC symbol. // Bind internal COFF symbol to MC symbol.
coff_symbol->MCData = &SymbolData; coff_symbol->MCData = &SymbolData;
SymbolMap[&SymbolData] = coff_symbol; SymbolMap[&SymbolData.getSymbol()] = coff_symbol;
} }
/// making a section real involves assigned it a number and putting /// making a section real involves assigned it a number and putting
@@ -509,7 +521,7 @@ bool WinCOFFObjectWriter::ExportSymbol(MCSymbolData const &SymbolData,
// For now, all non-variable symbols are exported, // For now, all non-variable symbols are exported,
// the linker will sort the rest out for us. // the linker will sort the rest out for us.
return !SymbolData.getSymbol().isVariable(); return SymbolData.isExternal() || !SymbolData.getSymbol().isVariable();
} }
bool WinCOFFObjectWriter::IsPhysicalSection(COFFSection *S) { bool WinCOFFObjectWriter::IsPhysicalSection(COFFSection *S) {
@@ -632,13 +644,13 @@ void WinCOFFObjectWriter::RecordRelocation(const MCAssembler &Asm,
MCSectionData const *SectionData = Fragment->getParent(); MCSectionData const *SectionData = Fragment->getParent();
// Mark this symbol as requiring an entry in the symbol table. // Mark this symbol as requiring an entry in the symbol table.
assert(SectionMap.find(SectionData) != SectionMap.end() && assert(SectionMap.find(&SectionData->getSection()) != SectionMap.end() &&
"Section must already have been defined in ExecutePostLayoutBinding!"); "Section must already have been defined in ExecutePostLayoutBinding!");
assert(SymbolMap.find(&A_SD) != SymbolMap.end() && assert(SymbolMap.find(&A_SD.getSymbol()) != SymbolMap.end() &&
"Symbol must already have been defined in ExecutePostLayoutBinding!"); "Symbol must already have been defined in ExecutePostLayoutBinding!");
COFFSection *coff_section = SectionMap[SectionData]; COFFSection *coff_section = SectionMap[&SectionData->getSection()];
COFFSymbol *coff_symbol = SymbolMap[&A_SD]; COFFSymbol *coff_symbol = SymbolMap[&A_SD.getSymbol()];
if (Target.getSymB()) { if (Target.getSymB()) {
if (&Target.getSymA()->getSymbol().getSection() if (&Target.getSymA()->getSymbol().getSection()
@@ -796,7 +808,7 @@ void WinCOFFObjectWriter::WriteObject(MCAssembler &Asm,
for (MCAssembler::const_iterator i = Asm.begin(), for (MCAssembler::const_iterator i = Asm.begin(),
e = Asm.end(); e = Asm.end();
i != e; i++) { i != e; i++) {
COFFSection *Sec = SectionMap[i]; COFFSection *Sec = SectionMap[&i->getSection()];
if (Sec->Number == -1) if (Sec->Number == -1)
continue; continue;

8
lib/MC/WinCOFFStreamer.cpp
View File

@@ -245,9 +245,11 @@ void WinCOFFStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
: true) && "Got non COFF section in the COFF backend!"); : true) && "Got non COFF section in the COFF backend!");
switch (Attribute) { switch (Attribute) {
case MCSA_WeakReference: case MCSA_WeakReference:
getAssembler().getOrCreateSymbolData(*Symbol).modifyFlags( case MCSA_Weak: {
COFF::SF_WeakReference, MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
COFF::SF_WeakReference); SD.modifyFlags(COFF::SF_WeakExternal, COFF::SF_WeakExternal);
SD.setExternal(true);
}
break; break;
case MCSA_Global: case MCSA_Global:

51
test/MC/COFF/weak.s Normal file
View File

@@ -0,0 +1,51 @@
// This tests that default-null weak symbols (a GNU extension) are created
// properly via the .weak directive.
// RUN: llvm-mc -filetype=obj < %s | coff-dump.py | FileCheck %s
.def _main;
.scl 2;
.type 32;
.endef
.text
.globl _main
.align 16, 0x90
_main: # @main
# BB#0: # %entry
subl $4, %esp
movl $_test_weak, %eax
testl %eax, %eax
je LBB0_2
# BB#1: # %if.then
calll _test_weak
movl $1, %eax
addl $4, %esp
ret
LBB0_2: # %return
xorl %eax, %eax
addl $4, %esp
ret
.weak _test_weak
// CHECK: Symbols = [
// CHECK: Name = _test_weak
// CHECK-NEXT: Value = 0
// CHECK-NEXT: SectionNumber = 0
// CHECK-NEXT: SimpleType = IMAGE_SYM_TYPE_NULL (0)
// CHECK-NEXT: ComplexType = IMAGE_SYM_DTYPE_NULL (0)
// CHECK-NEXT: StorageClass = IMAGE_SYM_CLASS_WEAK_EXTERNAL (105)
// CHECK-NEXT: NumberOfAuxSymbols = 1
// CHECK-NEXT: AuxillaryData =
// CHECK-NEXT: 05 00 00 00 02 00 00 00 - 00 00 00 00 00 00 00 00 |................|
// CHECK-NEXT: 00 00 |..|
// CHECK: Name = .weak._test_weak.default
// CHECK-NEXT: Value = 0
// CHECK-NEXT: SectionNumber = 65535
// CHECK-NEXT: SimpleType = IMAGE_SYM_TYPE_NULL (0)
// CHECK-NEXT: ComplexType = IMAGE_SYM_DTYPE_NULL (0)
// CHECK-NEXT: StorageClass = IMAGE_SYM_CLASS_EXTERNAL (2)
// CHECK-NEXT: NumberOfAuxSymbols = 0
// CHECK-NEXT: AuxillaryData =