mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-10-08 11:58:10 +00:00
85f2ecc697
actuall addresses in a .o file, so it is better to let the MachO writer compute it. This is good for two reasons. First, areas that shouldn't care about addresses now don't have access to it. Second, the layout of each section is independent. I should use this in a subsequent commit to speed it up. Most of the patch is just removing the section address computation. The two interesting parts are the change on how we handle padding in the end of sections and how MachO can get the address of a-b when a and b are in different sections. Since now the expression evaluation normally doesn't know the section address, it will think that a-b needs relocation and let the MachO writer know. Once it has computed the section addresses, it calls back the expression evaluation with the section addresses to resolve these expressions. The remaining problem is the handling of padding. Currently it will create a special alignment fragment at the end. Since that fragment doesn't update the alignment of the section, it needs the real address to be computed. Since now the layout will not compute a-b with a and b in different sections, the only effect that the special alignment fragment has is update the address size of the section. This can also be done by the MachO writer. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@121076 91177308-0d34-0410-b5e6-96231b3b80d8
113 lines
3.7 KiB
C++
113 lines
3.7 KiB
C++
//===- MCAsmLayout.h - Assembly Layout Object -------------------*- 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_MCASMLAYOUT_H
|
|
#define LLVM_MC_MCASMLAYOUT_H
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
|
|
|
namespace llvm {
|
|
class MCAssembler;
|
|
class MCFragment;
|
|
class MCSectionData;
|
|
class MCSymbolData;
|
|
|
|
/// Encapsulates the layout of an assembly file at a particular point in time.
|
|
///
|
|
/// Assembly may requiring compute multiple layouts for a particular assembly
|
|
/// file as part of the relaxation process. This class encapsulates the layout
|
|
/// at a single point in time in such a way that it is always possible to
|
|
/// efficiently compute the exact addresses of any symbol in the assembly file,
|
|
/// even during the relaxation process.
|
|
class MCAsmLayout {
|
|
public:
|
|
typedef llvm::SmallVectorImpl<MCSectionData*>::const_iterator const_iterator;
|
|
typedef llvm::SmallVectorImpl<MCSectionData*>::iterator iterator;
|
|
|
|
private:
|
|
MCAssembler &Assembler;
|
|
|
|
/// List of sections in layout order.
|
|
llvm::SmallVector<MCSectionData*, 16> SectionOrder;
|
|
|
|
/// The last fragment which was layed out, or 0 if nothing has been layed
|
|
/// out. Fragments are always layed out in order, so all fragments with a
|
|
/// lower ordinal will be up to date.
|
|
mutable MCFragment *LastValidFragment;
|
|
|
|
/// \brief Make sure that the layout for the given fragment is valid, lazily
|
|
/// computing it if necessary.
|
|
void EnsureValid(const MCFragment *F) const;
|
|
|
|
bool isSectionUpToDate(const MCSectionData *SD) const;
|
|
bool isFragmentUpToDate(const MCFragment *F) const;
|
|
|
|
public:
|
|
MCAsmLayout(MCAssembler &_Assembler);
|
|
|
|
/// Get the assembler object this is a layout for.
|
|
MCAssembler &getAssembler() const { return Assembler; }
|
|
|
|
/// \brief Invalidate all following fragments because a fragment has been resized. The
|
|
/// fragments size should have already been updated.
|
|
void Invalidate(MCFragment *F);
|
|
|
|
/// \brief Perform a full layout.
|
|
void LayoutFile();
|
|
|
|
/// \brief Perform layout for a single fragment, assuming that the previous
|
|
/// fragment has already been layed out correctly, and the parent section has
|
|
/// been initialized.
|
|
void LayoutFragment(MCFragment *Fragment);
|
|
|
|
/// @name Section Access (in layout order)
|
|
/// @{
|
|
|
|
llvm::SmallVectorImpl<MCSectionData*> &getSectionOrder() {
|
|
return SectionOrder;
|
|
}
|
|
const llvm::SmallVectorImpl<MCSectionData*> &getSectionOrder() const {
|
|
return SectionOrder;
|
|
}
|
|
|
|
/// @}
|
|
/// @name Fragment Layout Data
|
|
/// @{
|
|
|
|
/// \brief Get the effective size of the given fragment, as computed in the
|
|
/// current layout.
|
|
uint64_t getFragmentEffectiveSize(const MCFragment *F) const;
|
|
|
|
/// \brief Get the offset of the given fragment inside its containing section.
|
|
uint64_t getFragmentOffset(const MCFragment *F) const;
|
|
|
|
/// @}
|
|
/// @name Utility Functions
|
|
/// @{
|
|
|
|
/// \brief Get the address space size of the given section, as it effects
|
|
/// layout. This may differ from the size reported by \see getSectionSize() by
|
|
/// not including section tail padding.
|
|
uint64_t getSectionAddressSize(const MCSectionData *SD) const;
|
|
|
|
/// \brief Get the data size of the given section, as emitted to the object
|
|
/// file. This may include additional padding, or be 0 for virtual sections.
|
|
uint64_t getSectionFileSize(const MCSectionData *SD) const;
|
|
|
|
/// \brief Get the offset of the given symbol, as computed in the current
|
|
/// layout.
|
|
uint64_t getSymbolOffset(const MCSymbolData *SD) const;
|
|
|
|
/// @}
|
|
};
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif
|