mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-21 18:29:46 +00:00
One is that AArch64 has additional restrictions on when local relocations can be used. We have to take those into consideration when deciding to put a L symbol in the symbol table or not. The other is that ld64 requires the relocations to cstring to use linker visible symbols on AArch64. Thanks to Michael Zolotukhin for testing this! Remove doesSectionRequireSymbols. In an assembly expression like bar: .long L0 + 1 the intended semantics is that bar will contain a pointer one byte past L0. In sections that are merged by content (strings, 4 byte constants, etc), a single position in the section doesn't give the linker enough information. For example, it would not be able to tell a relocation must point to the end of a string, since that would look just like the start of the next. The solution used in ELF to use relocation with symbols if there is a non-zero addend. In MachO before this patch we would just keep all symbols in some sections. This would miss some cases (only cstrings on x86_64 were implemented) and was inefficient since most relocations have an addend of 0 and can be represented without the symbol. This patch implements the non-zero addend logic for MachO too. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@225644 91177308-0d34-0410-b5e6-96231b3b80d8
143 lines
5.0 KiB
C++
143 lines
5.0 KiB
C++
//===-- llvm/MC/MCAsmBackend.h - MC Asm Backend -----------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_MC_MCASMBACKEND_H
|
|
#define LLVM_MC_MCASMBACKEND_H
|
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
#include "llvm/MC/MCDirectives.h"
|
|
#include "llvm/MC/MCDwarf.h"
|
|
#include "llvm/MC/MCFixup.h"
|
|
#include "llvm/Support/DataTypes.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
namespace llvm {
|
|
class MCAsmLayout;
|
|
class MCAssembler;
|
|
class MCELFObjectTargetWriter;
|
|
struct MCFixupKindInfo;
|
|
class MCFragment;
|
|
class MCInst;
|
|
class MCRelaxableFragment;
|
|
class MCObjectWriter;
|
|
class MCSection;
|
|
class MCValue;
|
|
class raw_ostream;
|
|
|
|
/// MCAsmBackend - Generic interface to target specific assembler backends.
|
|
class MCAsmBackend {
|
|
MCAsmBackend(const MCAsmBackend &) LLVM_DELETED_FUNCTION;
|
|
void operator=(const MCAsmBackend &) LLVM_DELETED_FUNCTION;
|
|
|
|
protected: // Can only create subclasses.
|
|
MCAsmBackend();
|
|
|
|
unsigned HasDataInCodeSupport : 1;
|
|
|
|
public:
|
|
virtual ~MCAsmBackend();
|
|
|
|
/// lifetime management
|
|
virtual void reset() {}
|
|
|
|
/// createObjectWriter - Create a new MCObjectWriter instance for use by the
|
|
/// assembler backend to emit the final object file.
|
|
virtual MCObjectWriter *createObjectWriter(raw_ostream &OS) const = 0;
|
|
|
|
/// createELFObjectTargetWriter - Create a new ELFObjectTargetWriter to enable
|
|
/// non-standard ELFObjectWriters.
|
|
virtual MCELFObjectTargetWriter *createELFObjectTargetWriter() const {
|
|
llvm_unreachable("createELFObjectTargetWriter is not supported by asm "
|
|
"backend");
|
|
}
|
|
|
|
/// hasDataInCodeSupport - Check whether this target implements data-in-code
|
|
/// markers. If not, data region directives will be ignored.
|
|
bool hasDataInCodeSupport() const { return HasDataInCodeSupport; }
|
|
|
|
/// @name Target Fixup Interfaces
|
|
/// @{
|
|
|
|
/// getNumFixupKinds - Get the number of target specific fixup kinds.
|
|
virtual unsigned getNumFixupKinds() const = 0;
|
|
|
|
/// getFixupKindInfo - Get information on a fixup kind.
|
|
virtual const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const;
|
|
|
|
/// processFixupValue - Target hook to adjust the literal value of a fixup
|
|
/// if necessary. IsResolved signals whether the caller believes a relocation
|
|
/// is needed; the target can modify the value. The default does nothing.
|
|
virtual void processFixupValue(const MCAssembler &Asm,
|
|
const MCAsmLayout &Layout,
|
|
const MCFixup &Fixup, const MCFragment *DF,
|
|
const MCValue &Target, uint64_t &Value,
|
|
bool &IsResolved) {}
|
|
|
|
/// applyFixup - Apply the \p Value for given \p Fixup into the provided
|
|
/// data fragment, at the offset specified by the fixup and following the
|
|
/// fixup kind as appropriate.
|
|
virtual void applyFixup(const MCFixup &Fixup, char *Data, unsigned DataSize,
|
|
uint64_t Value, bool IsPCRel) const = 0;
|
|
|
|
/// @}
|
|
|
|
/// @name Target Relaxation Interfaces
|
|
/// @{
|
|
|
|
/// mayNeedRelaxation - Check whether the given instruction may need
|
|
/// relaxation.
|
|
///
|
|
/// \param Inst - The instruction to test.
|
|
virtual bool mayNeedRelaxation(const MCInst &Inst) const = 0;
|
|
|
|
/// fixupNeedsRelaxation - Target specific predicate for whether a given
|
|
/// fixup requires the associated instruction to be relaxed.
|
|
virtual bool fixupNeedsRelaxation(const MCFixup &Fixup, uint64_t Value,
|
|
const MCRelaxableFragment *DF,
|
|
const MCAsmLayout &Layout) const = 0;
|
|
|
|
/// RelaxInstruction - Relax the instruction in the given fragment to the next
|
|
/// wider instruction.
|
|
///
|
|
/// \param Inst The instruction to relax, which may be the same as the
|
|
/// output.
|
|
/// \param [out] Res On return, the relaxed instruction.
|
|
virtual void relaxInstruction(const MCInst &Inst, MCInst &Res) const = 0;
|
|
|
|
/// @}
|
|
|
|
/// getMinimumNopSize - Returns the minimum size of a nop in bytes on this
|
|
/// target. The assembler will use this to emit excess padding in situations
|
|
/// where the padding required for simple alignment would be less than the
|
|
/// minimum nop size.
|
|
///
|
|
virtual unsigned getMinimumNopSize() const { return 1; }
|
|
|
|
/// writeNopData - Write an (optimal) nop sequence of Count bytes to the given
|
|
/// output. If the target cannot generate such a sequence, it should return an
|
|
/// error.
|
|
///
|
|
/// \return - True on success.
|
|
virtual bool writeNopData(uint64_t Count, MCObjectWriter *OW) const = 0;
|
|
|
|
/// handleAssemblerFlag - Handle any target-specific assembler flags.
|
|
/// By default, do nothing.
|
|
virtual void handleAssemblerFlag(MCAssemblerFlag Flag) {}
|
|
|
|
/// \brief Generate the compact unwind encoding for the CFI instructions.
|
|
virtual uint32_t
|
|
generateCompactUnwindEncoding(ArrayRef<MCCFIInstruction>) const {
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
} // End llvm namespace
|
|
|
|
#endif
|