LCOV - code coverage report
Current view: top level - include/llvm/Target - TargetLoweringObjectFile.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 11 15 73.3 %
Date: 2017-09-14 15:23:50 Functions: 5 7 71.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- llvm/Target/TargetLoweringObjectFile.h - Object Info ----*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file implements classes used to handle lowerings specific to common
      11             : // object file formats.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #ifndef LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H
      16             : #define LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H
      17             : 
      18             : #include "llvm/ADT/ArrayRef.h"
      19             : #include "llvm/ADT/StringRef.h"
      20             : #include "llvm/IR/Module.h"
      21             : #include "llvm/MC/MCObjectFileInfo.h"
      22             : #include "llvm/MC/SectionKind.h"
      23             : #include <cstdint>
      24             : 
      25             : namespace llvm {
      26             : 
      27             : class GlobalValue;
      28             : class MachineModuleInfo;
      29             : class Mangler;
      30             : class MCContext;
      31             : class MCExpr;
      32             : class MCSection;
      33             : class MCSymbol;
      34             : class MCSymbolRefExpr;
      35             : class MCStreamer;
      36             : class MCValue;
      37             : class TargetMachine;
      38             : 
      39             : class TargetLoweringObjectFile : public MCObjectFileInfo {
      40             :   MCContext *Ctx = nullptr;
      41             : 
      42             :   /// Name-mangler for global names.
      43             :   Mangler *Mang = nullptr;
      44             : 
      45             : protected:
      46             :   bool SupportIndirectSymViaGOTPCRel = false;
      47             :   bool SupportGOTPCRelWithOffset = true;
      48             : 
      49             :   /// This section contains the static constructor pointer list.
      50             :   MCSection *StaticCtorSection = nullptr;
      51             : 
      52             :   /// This section contains the static destructor pointer list.
      53             :   MCSection *StaticDtorSection = nullptr;
      54             : 
      55             : public:
      56       51480 :   TargetLoweringObjectFile() = default;
      57             :   TargetLoweringObjectFile(const TargetLoweringObjectFile &) = delete;
      58             :   TargetLoweringObjectFile &
      59             :   operator=(const TargetLoweringObjectFile &) = delete;
      60             :   virtual ~TargetLoweringObjectFile();
      61             : 
      62             :   MCContext &getContext() const { return *Ctx; }
      63             :   Mangler &getMangler() const { return *Mang; }
      64             : 
      65             :   /// This method must be called before any actual lowering is done.  This
      66             :   /// specifies the current context for codegen, and gives the lowering
      67             :   /// implementations a chance to set up their default sections.
      68             :   virtual void Initialize(MCContext &ctx, const TargetMachine &TM);
      69             : 
      70             :   virtual void emitPersonalityValue(MCStreamer &Streamer, const DataLayout &TM,
      71             :                                     const MCSymbol *Sym) const;
      72             : 
      73             :   /// Emit the module-level metadata that the platform cares about.
      74         220 :   virtual void emitModuleMetadata(MCStreamer &Streamer, Module &M,
      75         220 :                                   const TargetMachine &TM) const {}
      76             : 
      77             :   /// Given a constant with the SectionKind, return a section that it should be
      78             :   /// placed in.
      79             :   virtual MCSection *getSectionForConstant(const DataLayout &DL,
      80             :                                            SectionKind Kind,
      81             :                                            const Constant *C,
      82             :                                            unsigned &Align) const;
      83             : 
      84             :   /// Classify the specified global variable into a set of target independent
      85             :   /// categories embodied in SectionKind.
      86             :   static SectionKind getKindForGlobal(const GlobalObject *GO,
      87             :                                       const TargetMachine &TM);
      88             : 
      89             :   /// This method computes the appropriate section to emit the specified global
      90             :   /// variable or function definition. This should not be passed external (or
      91             :   /// available externally) globals.
      92             :   MCSection *SectionForGlobal(const GlobalObject *GO, SectionKind Kind,
      93             :                               const TargetMachine &TM) const;
      94             : 
      95             :   /// This method computes the appropriate section to emit the specified global
      96             :   /// variable or function definition. This should not be passed external (or
      97             :   /// available externally) globals.
      98      142785 :   MCSection *SectionForGlobal(const GlobalObject *GO,
      99             :                               const TargetMachine &TM) const {
     100      142785 :     return SectionForGlobal(GO, getKindForGlobal(GO, TM), TM);
     101             :   }
     102             : 
     103             :   virtual void getNameWithPrefix(SmallVectorImpl<char> &OutName,
     104             :                                  const GlobalValue *GV,
     105             :                                  const TargetMachine &TM) const;
     106             : 
     107             :   virtual MCSection *getSectionForJumpTable(const Function &F,
     108             :                                             const TargetMachine &TM) const;
     109             : 
     110             :   virtual bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference,
     111             :                                                    const Function &F) const;
     112             : 
     113             :   /// Targets should implement this method to assign a section to globals with
     114             :   /// an explicit section specfied. The implementation of this method can
     115             :   /// assume that GO->hasSection() is true.
     116             :   virtual MCSection *
     117             :   getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
     118             :                            const TargetMachine &TM) const = 0;
     119             : 
     120             :   /// Return an MCExpr to use for a reference to the specified global variable
     121             :   /// from exception handling information.
     122             :   virtual const MCExpr *getTTypeGlobalReference(const GlobalValue *GV,
     123             :                                                 unsigned Encoding,
     124             :                                                 const TargetMachine &TM,
     125             :                                                 MachineModuleInfo *MMI,
     126             :                                                 MCStreamer &Streamer) const;
     127             : 
     128             :   /// Return the MCSymbol for a private symbol with global value name as its
     129             :   /// base, with the specified suffix.
     130             :   MCSymbol *getSymbolWithGlobalValueBase(const GlobalValue *GV,
     131             :                                          StringRef Suffix,
     132             :                                          const TargetMachine &TM) const;
     133             : 
     134             :   // The symbol that gets passed to .cfi_personality.
     135             :   virtual MCSymbol *getCFIPersonalitySymbol(const GlobalValue *GV,
     136             :                                             const TargetMachine &TM,
     137             :                                             MachineModuleInfo *MMI) const;
     138             : 
     139             :   const MCExpr *getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding,
     140             :                                   MCStreamer &Streamer) const;
     141             : 
     142          15 :   virtual MCSection *getStaticCtorSection(unsigned Priority,
     143             :                                           const MCSymbol *KeySym) const {
     144          15 :     return StaticCtorSection;
     145             :   }
     146             : 
     147           4 :   virtual MCSection *getStaticDtorSection(unsigned Priority,
     148             :                                           const MCSymbol *KeySym) const {
     149           4 :     return StaticDtorSection;
     150             :   }
     151             : 
     152             :   /// \brief Create a symbol reference to describe the given TLS variable when
     153             :   /// emitting the address in debug info.
     154             :   virtual const MCExpr *getDebugThreadLocalSymbol(const MCSymbol *Sym) const;
     155             : 
     156          20 :   virtual const MCExpr *lowerRelativeReference(const GlobalValue *LHS,
     157             :                                                const GlobalValue *RHS,
     158             :                                                const TargetMachine &TM) const {
     159          20 :     return nullptr;
     160             :   }
     161             : 
     162             :   /// \brief Target supports replacing a data "PC"-relative access to a symbol
     163             :   /// through another symbol, by accessing the later via a GOT entry instead?
     164             :   bool supportIndirectSymViaGOTPCRel() const {
     165             :     return SupportIndirectSymViaGOTPCRel;
     166             :   }
     167             : 
     168             :   /// \brief Target GOT "PC"-relative relocation supports encoding an additional
     169             :   /// binary expression with an offset?
     170             :   bool supportGOTPCRelWithOffset() const {
     171             :     return SupportGOTPCRelWithOffset;
     172             :   }
     173             : 
     174             :   /// \brief Get the target specific PC relative GOT entry relocation
     175           0 :   virtual const MCExpr *getIndirectSymViaGOTPCRel(const MCSymbol *Sym,
     176             :                                                   const MCValue &MV,
     177             :                                                   int64_t Offset,
     178             :                                                   MachineModuleInfo *MMI,
     179             :                                                   MCStreamer &Streamer) const {
     180           0 :     return nullptr;
     181             :   }
     182             : 
     183           0 :   virtual void emitLinkerFlagsForGlobal(raw_ostream &OS,
     184           0 :                                         const GlobalValue *GV) const {}
     185             : 
     186             : protected:
     187             :   virtual MCSection *SelectSectionForGlobal(const GlobalObject *GO,
     188             :                                             SectionKind Kind,
     189             :                                             const TargetMachine &TM) const = 0;
     190             : };
     191             : 
     192             : } // end namespace llvm
     193             : 
     194             : #endif // LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H

Generated by: LCOV version 1.13