mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-29 13:29:28 +00:00
Fixes PR19582. Previously, when an asm assignment (.set or =) was created, we would look up the section immediately in MCSymbol::setVariableValue. This caused symbols to receive the wrong section if the RHS of the assignment had not been seen yet. This had a knock-on effect in the object file emitters, causing them to emit extra symbols, or to give symbols the wrong visibility or the wrong section. For example, in the following asm: .data .Llocal: .text leaq .Llocal1(%rip), %rdi .Llocal1 = .Llocal2 .Llocal2 = .Llocal the first assignment would give .Llocal1 a null section, which would never get fixed up by the second assignment. This would cause the ELF object file emitter to consider .Llocal1 to be an undefined symbol and give it external linkage, even though .Llocal1 should not have been emitted at all in the object file. Or in the following asm: alias_to_local = Ltmp0 Ltmp0: the Mach-O object file emitter would give the alias_to_local symbol a n_type of N_SECT and a n_sect of 0. This is invalid under the Mach-O specification, which requires N_SECT symbols to receive a non-zero section number if the symbol is defined in a section in the object file. https://developer.apple.com/library/mac/documentation/DeveloperTools/Conceptual/MachORuntime/#//apple_ref/c/tag/nlist After this change we do not look up the section when the assignment is created, but instead look it up on demand and store it in Section, which is treated as a cache if the symbol is a variable symbol. This change also fixes a bug in MCExpr::FindAssociatedSection. Previously, if we saw a subtraction, we would return the first referenced section, even in cases where we should have been returning the absolute pseudo-section. Now we always return the absolute pseudo-section for expressions that subtract two section-derived expressions. This isn't always correct (e.g. if one of the sections ends up being laid out at an absolute address), but it's probably the best we can do without more context. This allows us to remove code in two places where we appear to have been working around this bug, in MachObjectWriter::markAbsoluteVariableSymbols and in X86AsmPrinter::EmitStartOfAsmFile. Re-applies r233595 (aka D8586), which was reverted in r233898. Differential Revision: http://reviews.llvm.org/D8798 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@233995 91177308-0d34-0410-b5e6-96231b3b80d8
190 lines
5.8 KiB
C++
190 lines
5.8 KiB
C++
//===- MCSymbol.h - Machine Code Symbols ------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file contains the declaration of the MCSymbol class.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_MC_MCSYMBOL_H
|
|
#define LLVM_MC_MCSYMBOL_H
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/MC/MCExpr.h"
|
|
#include "llvm/Support/Compiler.h"
|
|
|
|
namespace llvm {
|
|
class MCExpr;
|
|
class MCSection;
|
|
class MCContext;
|
|
class raw_ostream;
|
|
|
|
/// MCSymbol - Instances of this class represent a symbol name in the MC file,
|
|
/// and MCSymbols are created and unique'd by the MCContext class. MCSymbols
|
|
/// should only be constructed with valid names for the object file.
|
|
///
|
|
/// If the symbol is defined/emitted into the current translation unit, the
|
|
/// Section member is set to indicate what section it lives in. Otherwise, if
|
|
/// it is a reference to an external entity, it has a null section.
|
|
class MCSymbol {
|
|
// Special sentinal value for the absolute pseudo section.
|
|
//
|
|
// FIXME: Use a PointerInt wrapper for this?
|
|
static const MCSection *AbsolutePseudoSection;
|
|
|
|
/// Name - The name of the symbol. The referred-to string data is actually
|
|
/// held by the StringMap that lives in MCContext.
|
|
StringRef Name;
|
|
|
|
/// Section - The section the symbol is defined in. This is null for
|
|
/// undefined symbols, and the special AbsolutePseudoSection value for
|
|
/// absolute symbols. If this is a variable symbol, this caches the
|
|
/// variable value's section.
|
|
mutable const MCSection *Section;
|
|
|
|
/// Value - If non-null, the value for a variable symbol.
|
|
const MCExpr *Value;
|
|
|
|
/// IsTemporary - True if this is an assembler temporary label, which
|
|
/// typically does not survive in the .o file's symbol table. Usually
|
|
/// "Lfoo" or ".foo".
|
|
unsigned IsTemporary : 1;
|
|
|
|
/// \brief True if this symbol can be redefined.
|
|
unsigned IsRedefinable : 1;
|
|
|
|
/// IsUsed - True if this symbol has been used.
|
|
mutable unsigned IsUsed : 1;
|
|
|
|
private: // MCContext creates and uniques these.
|
|
friend class MCExpr;
|
|
friend class MCContext;
|
|
MCSymbol(StringRef name, bool isTemporary)
|
|
: Name(name), Section(nullptr), Value(nullptr),
|
|
IsTemporary(isTemporary), IsRedefinable(false), IsUsed(false) {}
|
|
|
|
MCSymbol(const MCSymbol&) = delete;
|
|
void operator=(const MCSymbol&) = delete;
|
|
const MCSection *getSectionPtr() const {
|
|
if (Section || !Value)
|
|
return Section;
|
|
return Section = Value->FindAssociatedSection();
|
|
}
|
|
|
|
public:
|
|
/// getName - Get the symbol name.
|
|
StringRef getName() const { return Name; }
|
|
|
|
/// @name Accessors
|
|
/// @{
|
|
|
|
/// isTemporary - Check if this is an assembler temporary symbol.
|
|
bool isTemporary() const { return IsTemporary; }
|
|
|
|
/// isUsed - Check if this is used.
|
|
bool isUsed() const { return IsUsed; }
|
|
void setUsed(bool Value) const { IsUsed = Value; }
|
|
|
|
/// \brief Check if this symbol is redefinable.
|
|
bool isRedefinable() const { return IsRedefinable; }
|
|
/// \brief Mark this symbol as redefinable.
|
|
void setRedefinable(bool Value) { IsRedefinable = Value; }
|
|
/// \brief Prepare this symbol to be redefined.
|
|
void redefineIfPossible() {
|
|
if (IsRedefinable) {
|
|
Value = nullptr;
|
|
Section = nullptr;
|
|
IsRedefinable = false;
|
|
}
|
|
}
|
|
|
|
/// @}
|
|
/// @name Associated Sections
|
|
/// @{
|
|
|
|
/// isDefined - Check if this symbol is defined (i.e., it has an address).
|
|
///
|
|
/// Defined symbols are either absolute or in some section.
|
|
bool isDefined() const {
|
|
return getSectionPtr() != nullptr;
|
|
}
|
|
|
|
/// isInSection - Check if this symbol is defined in some section (i.e., it
|
|
/// is defined but not absolute).
|
|
bool isInSection() const {
|
|
return isDefined() && !isAbsolute();
|
|
}
|
|
|
|
/// isUndefined - Check if this symbol undefined (i.e., implicitly defined).
|
|
bool isUndefined() const {
|
|
return !isDefined();
|
|
}
|
|
|
|
/// isAbsolute - Check if this is an absolute symbol.
|
|
bool isAbsolute() const {
|
|
return getSectionPtr() == AbsolutePseudoSection;
|
|
}
|
|
|
|
/// getSection - Get the section associated with a defined, non-absolute
|
|
/// symbol.
|
|
const MCSection &getSection() const {
|
|
assert(isInSection() && "Invalid accessor!");
|
|
return *getSectionPtr();
|
|
}
|
|
|
|
/// setSection - Mark the symbol as defined in the section \p S.
|
|
void setSection(const MCSection &S) {
|
|
assert(!isVariable() && "Cannot set section of variable");
|
|
Section = &S;
|
|
}
|
|
|
|
/// setUndefined - Mark the symbol as undefined.
|
|
void setUndefined() {
|
|
Section = nullptr;
|
|
}
|
|
|
|
/// @}
|
|
/// @name Variable Symbols
|
|
/// @{
|
|
|
|
/// isVariable - Check if this is a variable symbol.
|
|
bool isVariable() const {
|
|
return Value != nullptr;
|
|
}
|
|
|
|
/// getVariableValue() - Get the value for variable symbols.
|
|
const MCExpr *getVariableValue() const {
|
|
assert(isVariable() && "Invalid accessor!");
|
|
IsUsed = true;
|
|
return Value;
|
|
}
|
|
|
|
// AliasedSymbol() - If this is an alias (a = b), return the symbol
|
|
// we ultimately point to. For a non-alias, this just returns the symbol
|
|
// itself.
|
|
const MCSymbol &AliasedSymbol() const;
|
|
|
|
void setVariableValue(const MCExpr *Value);
|
|
|
|
/// @}
|
|
|
|
/// print - Print the value to the stream \p OS.
|
|
void print(raw_ostream &OS) const;
|
|
|
|
/// dump - Print the value to stderr.
|
|
void dump() const;
|
|
};
|
|
|
|
inline raw_ostream &operator<<(raw_ostream &OS, const MCSymbol &Sym) {
|
|
Sym.print(OS);
|
|
return OS;
|
|
}
|
|
} // end namespace llvm
|
|
|
|
#endif
|