include/llvm/Target/TargetLoweringObjectFile.h

   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/SmallVector.h"
  19 #include "llvm/ADT/StringMap.h"
  20
  21 namespace llvm {
  22   class MCSection;
  23   class MCContext;
  24   class GlobalValue;
  25   class Mangler;
  26   class TargetMachine;
  27
  28 /// SectionKind - This is a simple POD value that classifies the properties of
  29 /// a section.  A global variable is classified into the deepest possible
  30 /// classification, and then the target maps them onto their sections based on
  31 /// what capabilities they have.
  32 ///
  33 /// The comments below describe these as if they were an inheritance hierarchy
  34 /// in order to explain the predicates below.
  35 class SectionKind {
  36 public:
  37   enum Kind {
  38     /// Metadata - Debug info sections or other metadata.
  39     Metadata,
  40
  41     /// Text - Text section, used for functions and other executable code.
  42     Text,
  43
  44     /// ReadOnly - Data that is never written to at program runtime by the
  45     /// program or the dynamic linker.  Things in the top-level readonly
  46     /// SectionKind are not mergeable.
  47     ReadOnly,
  48
  49         /// MergeableCString - This is a special section for nul-terminated
  50         /// strings.  The linker can unique the C strings, knowing their
  51         /// semantics.  Because it uniques based on the nul terminators, the
  52         /// compiler can't put strings in this section that have embeded nuls
  53         /// in them.
  54         MergeableCString,
  55
  56         /// MergeableConst - These are sections for merging fixed-length
  57         /// constants together.  For example, this can be used to unique
  58         /// constant pool entries etc.
  59         MergeableConst,
  60
  61             /// MergeableConst4 - This is a section used by 4-byte constants,
  62             /// for example, floats.
  63             MergeableConst4,
  64
  65             /// MergeableConst8 - This is a section used by 8-byte constants,
  66             /// for example, doubles.
  67             MergeableConst8,
  68
  69             /// MergeableConst16 - This is a section used by 16-byte constants,
  70             /// for example, vectors.
  71             MergeableConst16,
  72
  73     /// Writeable - This is the base of all segments that need to be written
  74     /// to during program runtime.
  75
  76        /// ThreadLocal - This is the base of all TLS segments.  All TLS
  77        /// objects must be writeable, otherwise there is no reason for them to
  78        /// be thread local!
  79
  80            /// ThreadBSS - Zero-initialized TLS data objects.
  81            ThreadBSS,
  82
  83            /// ThreadData - Initialized TLS data objects.
  84            ThreadData,
  85
  86        /// GlobalWriteableData - Writeable data that is global (not thread
  87        /// local).
  88
  89            /// BSS - Zero initialized writeable data.
  90            BSS,
  91
  92            /// DataRel - This is the most general form of data that is written
  93            /// to by the program, it can have random relocations to arbitrary
  94            /// globals.
  95            DataRel,
  96
  97                /// DataRelLocal - This is writeable data that has a non-zero
  98                /// initializer and has relocations in it, but all of the
  99                /// relocations are known to be within the final linked image
 100                /// the global is linked into.
 101                DataRelLocal,
 102
 103                    /// DataNoRel - This is writeable data that has a non-zero
 104                    /// initializer, but whose initializer is known to have no
 105                    /// relocations.
 106                    DataNoRel,
 107
 108            /// ReadOnlyWithRel - These are global variables that are never
 109            /// written to by the program, but that have relocations, so they
 110            /// must be stuck in a writeable section so that the dynamic linker
 111            /// can write to them.  If it chooses to, the dynamic linker can
 112            /// mark the pages these globals end up on as read-only after it is
 113            /// done with its relocation phase.
 114            ReadOnlyWithRel,
 115
 116                /// ReadOnlyWithRelLocal - This is data that is readonly by the
 117                /// program, but must be writeable so that the dynamic linker
 118                /// can perform relocations in it.  This is used when we know
 119                /// that all the relocations are to globals in this final
 120                /// linked image.
 121                ReadOnlyWithRelLocal
 122
 123   };
 124
 125 private:
 126   Kind K : 6;
 127
 128   /// Weak - This is true if the referenced symbol is weak (i.e. linkonce,
 129   /// weak, weak_odr, etc).  This is orthogonal from the categorization.
 130   bool Weak : 1;
 131
 132   /// ExplicitSection - This is true if the global had a section explicitly
 133   /// specified on it.
 134   bool ExplicitSection : 1;
 135 public:
 136
 137   // FIXME: REMOVE.
 138   Kind getKind() const { return K; }
 139
 140   bool isWeak() const { return Weak; }
 141   bool hasExplicitSection() const { return ExplicitSection; }
 142
 143
 144   bool isMetadata() const { return K == Metadata; }
 145   bool isText() const { return K == Text; }
 146
 147   bool isReadOnly() const {
 148     return K == ReadOnly || K == MergeableCString || isMergeableConst();
 149   }
 150
 151   bool isMergeableCString() const { return K == MergeableCString; }
 152   bool isMergeableConst() const {
 153     return K == MergeableConst || K == MergeableConst4 ||
 154            K == MergeableConst8 || K == MergeableConst16;
 155   }
 156
 157   bool isMergeableConst4() const { return K == MergeableConst4; }
 158   bool isMergeableConst8() const { return K == MergeableConst8; }
 159   bool isMergeableConst16() const { return K == MergeableConst16; }
 160
 161   bool isWriteable() const {
 162     return isThreadLocal() || isGlobalWriteableData();
 163   }
 164
 165   bool isThreadLocal() const {
 166     return K == ThreadData || K == ThreadBSS;
 167   }
 168
 169   bool isThreadBSS() const { return K == ThreadBSS; }
 170   bool isThreadData() const { return K == ThreadData; }
 171
 172   bool isGlobalWriteableData() const {
 173     return isBSS() || isDataRel() || isReadOnlyWithRel();
 174   }
 175
 176   bool isBSS() const { return K == BSS; }
 177
 178   bool isDataRel() const {
 179     return K == DataRel || K == DataRelLocal || K == DataNoRel;
 180   }
 181
 182   bool isDataRelLocal() const {
 183     return K == DataRelLocal || K == DataNoRel;
 184   }
 185
 186   bool isDataNoRel() const { return K == DataNoRel; }
 187
 188   bool isReadOnlyWithRel() const {
 189     return K == ReadOnlyWithRel || K == ReadOnlyWithRelLocal;
 190   }
 191
 192   bool isReadOnlyWithRelLocal() const {
 193     return K == ReadOnlyWithRelLocal;
 194   }
 195
 196   static SectionKind get(Kind K, bool isWeak = false,
 197                          bool hasExplicitSection = false) {
 198     SectionKind Res;
 199     Res.K = K;
 200     Res.Weak = isWeak;
 201     Res.ExplicitSection = hasExplicitSection;
 202     return Res;
 203   }
 204 };
 205
 206
 207 class TargetLoweringObjectFile {
 208   MCContext *Ctx;
 209 protected:
 210
 211   TargetLoweringObjectFile();
 212
 213   /// TextSection - Section directive for standard text.
 214   ///
 215   const MCSection *TextSection;           // Defaults to ".text".
 216
 217   /// DataSection - Section directive for standard data.
 218   ///
 219   const MCSection *DataSection;           // Defaults to ".data".
 220
 221
 222
 223   // FIXME: SINK THESE.
 224   const MCSection *BSSSection_;
 225
 226   /// ReadOnlySection - This is the directive that is emitted to switch to a
 227   /// read-only section for constant data (e.g. data declared const,
 228   /// jump tables).
 229   const MCSection *ReadOnlySection;       // Defaults to NULL
 230
 231   /// TLSDataSection - Section directive for Thread Local data.
 232   ///
 233   const MCSection *TLSDataSection;        // Defaults to ".tdata".
 234
 235   /// TLSBSSSection - Section directive for Thread Local uninitialized data.
 236   /// Null if this target doesn't support a BSS section.
 237   ///
 238   const MCSection *TLSBSSSection;         // Defaults to ".tbss".
 239
 240   const MCSection *CStringSection_;
 241
 242 public:
 243   // FIXME: NONPUB.
 244   const MCSection *getOrCreateSection(const char *Name,
 245                                       bool isDirective,
 246                                       SectionKind::Kind K) const;
 247 public:
 248
 249   virtual ~TargetLoweringObjectFile();
 250
 251   /// Initialize - this method must be called before any actual lowering is
 252   /// done.  This specifies the current context for codegen, and gives the
 253   /// lowering implementations a chance to set up their default sections.
 254   virtual void Initialize(MCContext &ctx, const TargetMachine &TM) {
 255     Ctx = &ctx;
 256   }
 257
 258
 259   const MCSection *getTextSection() const { return TextSection; }
 260   const MCSection *getDataSection() const { return DataSection; }
 261
 262   /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively
 263   /// decide not to emit the UsedDirective for some symbols in llvm.used.
 264   /// FIXME: REMOVE this (rdar://7071300)
 265   virtual bool shouldEmitUsedDirectiveFor(const GlobalValue *GV,
 266                                           Mangler *) const {
 267     return (GV!=0);
 268   }
 269
 270   /// getSectionForMergeableConstant - Given a mergeable constant with the
 271   /// specified size and relocation information, return a section that it
 272   /// should be placed in.
 273   virtual const MCSection *
 274   getSectionForMergeableConstant(SectionKind Kind) const;
 275
 276   /// getKindForNamedSection - If this target wants to be able to override
 277   /// section flags based on the name of the section specified for a global
 278   /// variable, it can implement this.  This is used on ELF systems so that
 279   /// ".tbss" gets the TLS bit set etc.
 280   virtual SectionKind::Kind getKindForNamedSection(const char *Section,
 281                                                    SectionKind::Kind K) const{
 282     return K;
 283   }
 284
 285   /// SectionForGlobal - This method computes the appropriate section to emit
 286   /// the specified global variable or function definition.  This should not
 287   /// be passed external (or available externally) globals.
 288   const MCSection *SectionForGlobal(const GlobalValue *GV,
 289                                     Mangler *Mang,
 290                                     const TargetMachine &TM) const;
 291
 292   /// getSpecialCasedSectionGlobals - Allow the target to completely override
 293   /// section assignment of a global.
 294   /// FIXME: ELIMINATE this by making PIC16 implement ADDRESS with
 295   /// getFlagsForNamedSection.
 296   virtual const MCSection *
 297   getSpecialCasedSectionGlobals(const GlobalValue *GV, Mangler *Mang,
 298                                 SectionKind Kind) const {
 299     return 0;
 300   }
 301
 302   /// getSectionFlagsAsString - Turn the flags in the specified SectionKind
 303   /// into a string that can be printed to the assembly file after the
 304   /// ".section foo" part of a section directive.
 305   virtual void getSectionFlagsAsString(SectionKind Kind,
 306                                        SmallVectorImpl<char> &Str) const {
 307   }
 308
 309 protected:
 310   virtual const MCSection *
 311   SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 312                          Mangler *Mang, const TargetMachine &TM) const;
 313 };
 314
 315
 316
 317
 318 class TargetLoweringObjectFileELF : public TargetLoweringObjectFile {
 319   bool AtIsCommentChar;  // True if @ is the comment character on this target.
 320   bool HasCrazyBSS;
 321 public:
 322   /// ELF Constructor - AtIsCommentChar is true if the CommentCharacter from TAI
 323   /// is "@".
 324   TargetLoweringObjectFileELF(bool atIsCommentChar = false,
 325                               // FIXME: REMOVE AFTER UNIQUING IS FIXED.
 326                               bool hasCrazyBSS = false)
 327     : AtIsCommentChar(atIsCommentChar), HasCrazyBSS(hasCrazyBSS) {}
 328
 329   virtual void Initialize(MCContext &Ctx, const TargetMachine &TM);
 330
 331
 332   /// getSectionForMergeableConstant - Given a mergeable constant with the
 333   /// specified size and relocation information, return a section that it
 334   /// should be placed in.
 335   virtual const MCSection *
 336   getSectionForMergeableConstant(SectionKind Kind) const;
 337
 338   virtual SectionKind::Kind getKindForNamedSection(const char *Section,
 339                                                    SectionKind::Kind K) const;
 340   void getSectionFlagsAsString(SectionKind Kind,
 341                                SmallVectorImpl<char> &Str) const;
 342
 343   virtual const MCSection *
 344   SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 345                          Mangler *Mang, const TargetMachine &TM) const;
 346 protected:
 347   const MCSection *DataRelSection;
 348   const MCSection *DataRelLocalSection;
 349   const MCSection *DataRelROSection;
 350   const MCSection *DataRelROLocalSection;
 351
 352   const MCSection *MergeableConst4Section;
 353   const MCSection *MergeableConst8Section;
 354   const MCSection *MergeableConst16Section;
 355 };
 356
 357
 358
 359 class TargetLoweringObjectFileMachO : public TargetLoweringObjectFile {
 360   const MCSection *TextCoalSection;
 361   const MCSection *ConstTextCoalSection;
 362   const MCSection *ConstDataCoalSection;
 363   const MCSection *ConstDataSection;
 364   const MCSection *DataCoalSection;
 365   const MCSection *FourByteConstantSection;
 366   const MCSection *EightByteConstantSection;
 367   const MCSection *SixteenByteConstantSection;
 368 public:
 369
 370   virtual void Initialize(MCContext &Ctx, const TargetMachine &TM);
 371
 372   virtual const MCSection *
 373   SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 374                          Mangler *Mang, const TargetMachine &TM) const;
 375
 376   virtual const MCSection *
 377   getSectionForMergeableConstant(SectionKind Kind) const;
 378
 379   /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively
 380   /// decide not to emit the UsedDirective for some symbols in llvm.used.
 381   /// FIXME: REMOVE this (rdar://7071300)
 382   virtual bool shouldEmitUsedDirectiveFor(const GlobalValue *GV,
 383                                           Mangler *) const;
 384 };
 385
 386
 387
 388 class TargetLoweringObjectFileCOFF : public TargetLoweringObjectFile {
 389 public:
 390   virtual void Initialize(MCContext &Ctx, const TargetMachine &TM);
 391
 392   virtual void getSectionFlagsAsString(SectionKind Kind,
 393                                        SmallVectorImpl<char> &Str) const;
 394
 395   virtual const MCSection *
 396   SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 397                          Mangler *Mang, const TargetMachine &TM) const;
 398 };
 399
 400 } // end namespace llvm
 401
 402 #endif