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/IR/Module.h" 20#include "llvm/MC/MCObjectFileInfo.h" 21#include "llvm/MC/SectionKind.h" 22 23namespace llvm { 24 class MachineModuleInfo; 25 class Mangler; 26 class MCContext; 27 class MCExpr; 28 class MCSection; 29 class MCSymbol; 30 class MCSymbolRefExpr; 31 class MCStreamer; 32 class GlobalValue; 33 class TargetMachine; 34 35class TargetLoweringObjectFile : public MCObjectFileInfo { 36 MCContext *Ctx; 37 38 TargetLoweringObjectFile( 39 const TargetLoweringObjectFile&) LLVM_DELETED_FUNCTION; 40 void operator=(const TargetLoweringObjectFile&) LLVM_DELETED_FUNCTION; 41 42public: 43 MCContext &getContext() const { return *Ctx; } 44 45 TargetLoweringObjectFile() : MCObjectFileInfo(), Ctx(0) {} 46 47 virtual ~TargetLoweringObjectFile(); 48 49 /// Initialize - this method must be called before any actual lowering is 50 /// done. This specifies the current context for codegen, and gives the 51 /// lowering implementations a chance to set up their default sections. 52 virtual void Initialize(MCContext &ctx, const TargetMachine &TM); 53 54 virtual void emitPersonalityValue(MCStreamer &Streamer, 55 const TargetMachine &TM, 56 const MCSymbol *Sym) const; 57 58 /// emitModuleFlags - Emit the module flags that the platform cares about. 59 virtual void emitModuleFlags(MCStreamer &, 60 ArrayRef<Module::ModuleFlagEntry>, 61 Mangler *, const TargetMachine &) const { 62 } 63 64 /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively 65 /// decide not to emit the UsedDirective for some symbols in llvm.used. 66 /// FIXME: REMOVE this (rdar://7071300) 67 virtual bool shouldEmitUsedDirectiveFor(const GlobalValue *GV, 68 Mangler *) const { 69 return GV != 0; 70 } 71 72 /// getSectionForConstant - Given a constant with the SectionKind, return a 73 /// section that it should be placed in. 74 virtual const MCSection *getSectionForConstant(SectionKind Kind) const; 75 76 /// getKindForGlobal - Classify the specified global variable into a set of 77 /// target independent categories embodied in SectionKind. 78 static SectionKind getKindForGlobal(const GlobalValue *GV, 79 const TargetMachine &TM); 80 81 /// SectionForGlobal - This method computes the appropriate section to emit 82 /// the specified global variable or function definition. This should not 83 /// be passed external (or available externally) globals. 84 const MCSection *SectionForGlobal(const GlobalValue *GV, 85 SectionKind Kind, Mangler *Mang, 86 const TargetMachine &TM) const; 87 88 /// SectionForGlobal - This method computes the appropriate section to emit 89 /// the specified global variable or function definition. This should not 90 /// be passed external (or available externally) globals. 91 const MCSection *SectionForGlobal(const GlobalValue *GV, 92 Mangler *Mang, 93 const TargetMachine &TM) const { 94 return SectionForGlobal(GV, getKindForGlobal(GV, TM), Mang, TM); 95 } 96 97 /// getExplicitSectionGlobal - Targets should implement this method to assign 98 /// a section to globals with an explicit section specfied. The 99 /// implementation of this method can assume that GV->hasSection() is true. 100 virtual const MCSection * 101 getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind, 102 Mangler *Mang, const TargetMachine &TM) const = 0; 103 104 /// getSpecialCasedSectionGlobals - Allow the target to completely override 105 /// section assignment of a global. 106 virtual const MCSection * 107 getSpecialCasedSectionGlobals(const GlobalValue *GV, Mangler *Mang, 108 SectionKind Kind) const { 109 return 0; 110 } 111 112 /// getTTypeGlobalReference - Return an MCExpr to use for a reference 113 /// to the specified global variable from exception handling information. 114 /// 115 virtual const MCExpr * 116 getTTypeGlobalReference(const GlobalValue *GV, Mangler *Mang, 117 MachineModuleInfo *MMI, unsigned Encoding, 118 MCStreamer &Streamer) const; 119 120 // getCFIPersonalitySymbol - The symbol that gets passed to .cfi_personality. 121 virtual MCSymbol * 122 getCFIPersonalitySymbol(const GlobalValue *GV, Mangler *Mang, 123 MachineModuleInfo *MMI) const; 124 125 /// 126 const MCExpr * 127 getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding, 128 MCStreamer &Streamer) const; 129 130 virtual const MCSection * 131 getStaticCtorSection(unsigned Priority = 65535) const { 132 (void)Priority; 133 return StaticCtorSection; 134 } 135 virtual const MCSection * 136 getStaticDtorSection(unsigned Priority = 65535) const { 137 (void)Priority; 138 return StaticDtorSection; 139 } 140 141 /// \brief Create a symbol reference to describe the given TLS variable when 142 /// emitting the address in debug info. 143 virtual const MCExpr *getDebugThreadLocalSymbol(const MCSymbol *Sym) const; 144 145protected: 146 virtual const MCSection * 147 SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind, 148 Mangler *Mang, const TargetMachine &TM) const; 149}; 150 151} // end namespace llvm 152 153#endif 154