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 protected:
 126   Kind K : 6;
 127
 128 public:
 129
 130   // FIXME: REMOVE.
 131   Kind getKind() const { return K; }
 132
 133   bool isMetadata() const { return K == Metadata; }
 134   bool isText() const { return K == Text; }
 135
 136   bool isReadOnly() const {
 137     return K == ReadOnly || K == MergeableCString || isMergeableConst();
 138   }
 139
 140   bool isMergeableCString() const { return K == MergeableCString; }
 141   bool isMergeableConst() const {
 142     return K == MergeableConst || K == MergeableConst4 ||
 143            K == MergeableConst8 || K == MergeableConst16;
 144   }
 145
 146   bool isMergeableConst4() const { return K == MergeableConst4; }
 147   bool isMergeableConst8() const { return K == MergeableConst8; }
 148   bool isMergeableConst16() const { return K == MergeableConst16; }
 149
 150   bool isWriteable() const {
 151     return isThreadLocal() || isGlobalWriteableData();
 152   }
 153
 154   bool isThreadLocal() const {
 155     return K == ThreadData || K == ThreadBSS;
 156   }
 157
 158   bool isThreadBSS() const { return K == ThreadBSS; }
 159   bool isThreadData() const { return K == ThreadData; }
 160
 161   bool isGlobalWriteableData() const {
 162     return isBSS() || isDataRel() || isReadOnlyWithRel();
 163   }
 164
 165   bool isBSS() const { return K == BSS; }
 166
 167   bool isDataRel() const {
 168     return K == DataRel || K == DataRelLocal || K == DataNoRel;
 169   }
 170
 171   bool isDataRelLocal() const {
 172     return K == DataRelLocal || K == DataNoRel;
 173   }
 174
 175   bool isDataNoRel() const { return K == DataNoRel; }
 176
 177   bool isReadOnlyWithRel() const {
 178     return K == ReadOnlyWithRel || K == ReadOnlyWithRelLocal;
 179   }
 180
 181   bool isReadOnlyWithRelLocal() const {
 182     return K == ReadOnlyWithRelLocal;
 183   }
 184
 185   static SectionKind get(Kind K) {
 186     SectionKind Res;
 187     Res.K = K;
 188     return Res;
 189   }
 190 };
 191
 192
 193 /// SectionInfo - This class is a target-independent classification of a global
 194 /// which is used to simplify target-specific code by exposing common
 195 /// predicates.
 196 class SectionInfo : public SectionKind {
 197   /// Weak - This is true if the referenced symbol is weak (i.e. linkonce,
 198   /// weak, weak_odr, etc).  This is orthogonal from the categorization.
 199   bool Weak : 1;
 200
 201 public:
 202
 203   /// Weak - This is true if the referenced symbol is weak (i.e. linkonce,
 204   /// weak, weak_odr, etc).  This is orthogonal from the categorization.
 205   bool isWeak() const { return Weak; }
 206
 207   static SectionInfo get(Kind K, bool isWeak = false) {
 208     SectionInfo Res;
 209     Res.K = K;
 210     Res.Weak = isWeak;
 211     return Res;
 212   }
 213   static SectionInfo get(SectionKind K, bool isWeak = false) {
 214     SectionInfo Res;
 215     *(SectionKind*)&Res = K;
 216     Res.Weak = isWeak;
 217     return Res;
 218   }
 219 };
 220
 221 class TargetLoweringObjectFile {
 222   MCContext *Ctx;
 223 protected:
 224
 225   TargetLoweringObjectFile();
 226
 227   /// TextSection - Section directive for standard text.
 228   ///
 229   const MCSection *TextSection;           // Defaults to ".text".
 230
 231   /// DataSection - Section directive for standard data.
 232   ///
 233   const MCSection *DataSection;           // Defaults to ".data".
 234
 235
 236
 237   // FIXME: SINK THESE.
 238   const MCSection *BSSSection_;
 239
 240   /// ReadOnlySection - This is the directive that is emitted to switch to a
 241   /// read-only section for constant data (e.g. data declared const,
 242   /// jump tables).
 243   const MCSection *ReadOnlySection;       // Defaults to NULL
 244
 245   /// TLSDataSection - Section directive for Thread Local data.
 246   ///
 247   const MCSection *TLSDataSection;        // Defaults to ".tdata".
 248
 249   /// TLSBSSSection - Section directive for Thread Local uninitialized data.
 250   /// Null if this target doesn't support a BSS section.
 251   ///
 252   const MCSection *TLSBSSSection;         // Defaults to ".tbss".
 253
 254   const MCSection *CStringSection_;
 255
 256 public:
 257   // FIXME: NONPUB.
 258   const MCSection *getOrCreateSection(const char *Name,
 259                                       bool isDirective,
 260                                       SectionKind K) const;
 261 public:
 262
 263   virtual ~TargetLoweringObjectFile();
 264
 265   /// Initialize - this method must be called before any actual lowering is
 266   /// done.  This specifies the current context for codegen, and gives the
 267   /// lowering implementations a chance to set up their default sections.
 268   virtual void Initialize(MCContext &ctx, const TargetMachine &TM) {
 269     Ctx = &ctx;
 270   }
 271
 272
 273   const MCSection *getTextSection() const { return TextSection; }
 274   const MCSection *getDataSection() const { return DataSection; }
 275
 276   /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively
 277   /// decide not to emit the UsedDirective for some symbols in llvm.used.
 278   /// FIXME: REMOVE this (rdar://7071300)
 279   virtual bool shouldEmitUsedDirectiveFor(const GlobalValue *GV,
 280                                           Mangler *) const {
 281     return (GV!=0);
 282   }
 283
 284   /// getSectionForMergeableConstant - Given a mergeable constant with the
 285   /// specified size and relocation information, return a section that it
 286   /// should be placed in.
 287   virtual const MCSection *
 288   getSectionForMergeableConstant(SectionKind Kind) const;
 289
 290   /// getKindForNamedSection - If this target wants to be able to override
 291   /// section flags based on the name of the section specified for a global
 292   /// variable, it can implement this.  This is used on ELF systems so that
 293   /// ".tbss" gets the TLS bit set etc.
 294   virtual SectionKind getKindForNamedSection(const char *Section,
 295                                              SectionKind K) const {
 296     return K;
 297   }
 298
 299   /// SectionForGlobal - This method computes the appropriate section to emit
 300   /// the specified global variable or function definition.  This should not
 301   /// be passed external (or available externally) globals.
 302   const MCSection *SectionForGlobal(const GlobalValue *GV,
 303                                     Mangler *Mang,
 304                                     const TargetMachine &TM) const;
 305
 306   /// getSpecialCasedSectionGlobals - Allow the target to completely override
 307   /// section assignment of a global.
 308   /// FIXME: ELIMINATE this by making PIC16 implement ADDRESS with
 309   /// getFlagsForNamedSection.
 310   virtual const MCSection *
 311   getSpecialCasedSectionGlobals(const GlobalValue *GV, Mangler *Mang,
 312                                 SectionInfo Kind) const {
 313     return 0;
 314   }
 315
 316   /// getSectionFlagsAsString - Turn the flags in the specified SectionKind
 317   /// into a string that can be printed to the assembly file after the
 318   /// ".section foo" part of a section directive.
 319   virtual void getSectionFlagsAsString(SectionKind Kind,
 320                                        SmallVectorImpl<char> &Str) const {
 321   }
 322
 323 protected:
 324   virtual const MCSection *
 325   SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
 326                          Mangler *Mang, const TargetMachine &TM) const;
 327 };
 328
 329
 330
 331
 332 class TargetLoweringObjectFileELF : public TargetLoweringObjectFile {
 333   bool AtIsCommentChar;  // True if @ is the comment character on this target.
 334   bool HasCrazyBSS;
 335 public:
 336   /// ELF Constructor - AtIsCommentChar is true if the CommentCharacter from TAI
 337   /// is "@".
 338   TargetLoweringObjectFileELF(bool atIsCommentChar = false,
 339                               // FIXME: REMOVE AFTER UNIQUING IS FIXED.
 340                               bool hasCrazyBSS = false)
 341     : AtIsCommentChar(atIsCommentChar), HasCrazyBSS(hasCrazyBSS) {}
 342
 343   virtual void Initialize(MCContext &Ctx, const TargetMachine &TM);
 344
 345
 346   /// getSectionForMergeableConstant - Given a mergeable constant with the
 347   /// specified size and relocation information, return a section that it
 348   /// should be placed in.
 349   virtual const MCSection *
 350   getSectionForMergeableConstant(SectionKind Kind) const;
 351
 352   virtual SectionKind getKindForNamedSection(const char *Section,
 353                                              SectionKind K) const;
 354   void getSectionFlagsAsString(SectionKind Kind,
 355                                SmallVectorImpl<char> &Str) const;
 356
 357   virtual const MCSection *
 358   SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
 359                          Mangler *Mang, const TargetMachine &TM) const;
 360 protected:
 361   const MCSection *DataRelSection;
 362   const MCSection *DataRelLocalSection;
 363   const MCSection *DataRelROSection;
 364   const MCSection *DataRelROLocalSection;
 365
 366   const MCSection *MergeableConst4Section;
 367   const MCSection *MergeableConst8Section;
 368   const MCSection *MergeableConst16Section;
 369 };
 370
 371
 372
 373 class TargetLoweringObjectFileMachO : public TargetLoweringObjectFile {
 374   const MCSection *TextCoalSection;
 375   const MCSection *ConstTextCoalSection;
 376   const MCSection *ConstDataCoalSection;
 377   const MCSection *ConstDataSection;
 378   const MCSection *DataCoalSection;
 379   const MCSection *FourByteConstantSection;
 380   const MCSection *EightByteConstantSection;
 381   const MCSection *SixteenByteConstantSection;
 382 public:
 383
 384   virtual void Initialize(MCContext &Ctx, const TargetMachine &TM);
 385
 386   virtual const MCSection *
 387   SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
 388                          Mangler *Mang, const TargetMachine &TM) const;
 389
 390   virtual const MCSection *
 391   getSectionForMergeableConstant(SectionKind Kind) const;
 392
 393   /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively
 394   /// decide not to emit the UsedDirective for some symbols in llvm.used.
 395   /// FIXME: REMOVE this (rdar://7071300)
 396   virtual bool shouldEmitUsedDirectiveFor(const GlobalValue *GV,
 397                                           Mangler *) const;
 398 };
 399
 400
 401
 402 class TargetLoweringObjectFileCOFF : public TargetLoweringObjectFile {
 403 public:
 404   virtual void Initialize(MCContext &Ctx, const TargetMachine &TM);
 405
 406   virtual void getSectionFlagsAsString(SectionKind Kind,
 407                                        SmallVectorImpl<char> &Str) const;
 408
 409   virtual const MCSection *
 410   SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
 411                          Mangler *Mang, const TargetMachine &TM) const;
 412 };
 413
 414 } // end namespace llvm
 415
 416 #endif