include/mcld/Target/TargetLDBackend.h

//===-- llvm/Target/TargetLDBackend.h - Target LD Backend -----*- C++ -*-===//
//
//                     The MCLinker Project
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TARGET_TARGETLDBACKEND_H
#define LLVM_TARGET_TARGETLDBACKEND_H

#include <llvm/Support/DataTypes.h>
#include <mcld/MC/MCLDOutput.h>
#include <mcld/LD/EhFrame.h>

namespace mcld {

class MCLinker;
class Relocation;
class RelocationFactory;
class Layout;
class ArchiveReader;
class ObjectReader;
class DynObjReader;
class ObjectWriter;
class DynObjWriter;
class ExecWriter;
class LDContext;
class SectionMap;
class Output;
class MCLDInfo;
class SymbolCategory;
class Input;
class LDFileFormat;
class GOT;
class MemoryAreaFactory;

//===----------------------------------------------------------------------===//
/// TargetLDBackend - Generic interface to target specific assembler backends.
///
class TargetLDBackend
{
  TargetLDBackend(const TargetLDBackend &);   // DO NOT IMPLEMENT
  void operator=(const TargetLDBackend &);  // DO NOT IMPLEMENT

protected:
  TargetLDBackend();

public:
  virtual ~TargetLDBackend();

  // -----  target dependent  ----- //
  virtual bool initTargetSectionMap(SectionMap& pSectionMap) { return true;}
  virtual void initTargetSegments(MCLinker& pLinker) { }
  virtual void initTargetSections(MCLinker& pLinker) { }
  virtual void initTargetSymbols(MCLinker& pLinker, const Output& pOutput) { }
  virtual void initTargetRelocation(MCLinker& pLinker) { }
  virtual bool initStandardSymbols(MCLinker& pLinker, const Output& pOutput) = 0;
  virtual bool initRelocFactory(const MCLinker& pLinker) = 0;

  virtual RelocationFactory* getRelocFactory() = 0;

  /// scanRelocation - When read in relocations, backend can do any modification
  /// to relocation and generate empty entries, such as GOT, dynamic relocation
  /// entries and other target dependent entries. These entries are generated
  /// for layout to adjust the ouput offset.
  /// @param pReloc - a read in relocation entry
  /// @param pInputSym - the input LDSymbol of relocation target symbol
  /// @param pOutput - the ouput file
  virtual void scanRelocation(Relocation& pReloc,
                              const LDSymbol& pInputSym,
                              MCLinker& pLinker,
                              const MCLDInfo& pLDInfo,
                              const Output& pOutput,
                              const LDSection& pSection) = 0;

  // -----  format dependent  ----- //
  virtual bool initArchiveReader(MCLinker&,
                                 MCLDInfo&,
                                 MemoryAreaFactory&) = 0;
  virtual bool initObjectReader(MCLinker&) = 0;
  virtual bool initDynObjReader(MCLinker&) = 0;
  virtual bool initObjectWriter(MCLinker&) = 0;
  virtual bool initDynObjWriter(MCLinker&) = 0;
  virtual bool initExecWriter(MCLinker&) = 0;

  virtual bool initExecSections(MCLinker&) = 0;
  virtual bool initDynObjSections(MCLinker&) = 0;

  virtual ArchiveReader *getArchiveReader() = 0;
  virtual ObjectReader *getObjectReader() = 0;
  virtual DynObjReader *getDynObjReader() = 0;
  virtual ObjectWriter *getObjectWriter() = 0;
  virtual DynObjWriter *getDynObjWriter() = 0;
  virtual ExecWriter *getExecWriter() = 0;

  virtual LDFileFormat* getDynObjFileFormat() = 0;
  virtual LDFileFormat* getExecFileFormat() = 0;

  /// preLayout - Backend can do any needed modification before layout
  virtual void preLayout(const Output& pOutput,
                         const MCLDInfo& pInfo,
                         MCLinker& pLinker) = 0;

  /// postLayout -Backend can do any needed modification after layout
  virtual void postLayout(const Output& pOutput,
                          const MCLDInfo& pInfo,
                          MCLinker& pLinker) = 0;

  /// postProcessing - Backend can do any needed modification in the final stage
  virtual void postProcessing(const Output& pOutput,
                              const MCLDInfo& pInfo,
                              MCLinker& pLinker) = 0;

  /// Is the target machine little endian? **/
  virtual bool isLittleEndian() const = 0;

  /// bit class. the bit length of the target machine, 32 or 64 **/
  virtual unsigned int bitclass() const = 0;

  /// the common page size of the target machine
  virtual uint64_t commonPageSize(const MCLDInfo& pInfo) const = 0;

  /// the abi page size of the target machine
  virtual uint64_t abiPageSize(const MCLDInfo& pInfo) const = 0;

  /// section start offset in the output file
  virtual size_t sectionStartOffset() const = 0;

  /// computeSectionOrder - compute the layout order of the given section
  virtual unsigned int getSectionOrder(const Output& pOutput,
                                       const LDSection& pSectHdr,
                                       const MCLDInfo& pInfo) const = 0;

  /// sizeNamePools - compute the size of regular name pools
  /// In ELF executable files, regular name pools are .symtab, .strtab.,
  /// .dynsym, .dynstr, and .hash
  virtual void
  sizeNamePools(const Output& pOutput,
                const SymbolCategory& pSymbols,
                const MCLDInfo& pLDInfo) = 0;

  /// finalizeSymbol - Linker checks pSymbol.reserved() if it's not zero,
  /// then it will ask backend to finalize the symbol value.
  /// @return ture - if backend set the symbol value sucessfully
  /// @return false - if backend do not recognize the symbol
  virtual bool finalizeSymbols(MCLinker& pLinker, const Output& pOutput) = 0;

  /// allocateCommonSymbols - allocate common symbols in the corresponding
  /// sections.
  virtual bool allocateCommonSymbols(const MCLDInfo& pLDInfo, MCLinker& pLinker) const = 0;

  /// readSection - read a target dependent section
  virtual bool readSection(Input& pInput,
                           MCLinker& pLinker,
                           LDSection& pInputSectHdr)
  { return true; }

  /// dyld - the name of the default dynamic linker
  virtual const char* dyld() const = 0;

  /// sizeInterp - compute the size of program interpreter's name
  /// In ELF executables, this is the length of dynamic linker's path name
  virtual void sizeInterp(const Output& pOutput, const MCLDInfo& pLDInfo) = 0;

public:
  EhFrame* getEhFrame();

  const EhFrame* getEhFrame() const;

private:
  /// m_pEhFrame - section .eh_frame
  EhFrame* m_pEhFrame;

};

} // End mcld namespace

#endif