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
 263   /// getSectionForMergeableConstant - Given a mergeable constant with the
 264   /// specified size and relocation information, return a section that it
 265   /// should be placed in.
 266   virtual const MCSection *
 267   getSectionForMergeableConstant(SectionKind Kind) const;
 268
 269   /// getKindForNamedSection - If this target wants to be able to override
 270   /// section flags based on the name of the section specified for a global
 271   /// variable, it can implement this.  This is used on ELF systems so that
 272   /// ".tbss" gets the TLS bit set etc.
 273   virtual SectionKind::Kind getKindForNamedSection(const char *Section,
 274                                                    SectionKind::Kind K) const{
 275     return K;
 276   }
 277
 278   /// SectionForGlobal - This method computes the appropriate section to emit
 279   /// the specified global variable or function definition.  This should not
 280   /// be passed external (or available externally) globals.
 281   const MCSection *SectionForGlobal(const GlobalValue *GV,
 282                                     Mangler *Mang,
 283                                     const TargetMachine &TM) const;
 284
 285   /// getSpecialCasedSectionGlobals - Allow the target to completely override
 286   /// section assignment of a global.
 287   /// FIXME: ELIMINATE this by making PIC16 implement ADDRESS with
 288   /// getFlagsForNamedSection.
 289   virtual const MCSection *
 290   getSpecialCasedSectionGlobals(const GlobalValue *GV, Mangler *Mang,
 291                                 SectionKind Kind) const {
 292     return 0;
 293   }
 294
 295   /// getSectionFlagsAsString - Turn the flags in the specified SectionKind
 296   /// into a string that can be printed to the assembly file after the
 297   /// ".section foo" part of a section directive.
 298   virtual void getSectionFlagsAsString(SectionKind Kind,
 299                                        SmallVectorImpl<char> &Str) const {
 300   }
 301
 302 protected:
 303   virtual const MCSection *
 304   SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 305                          Mangler *Mang, const TargetMachine &TM) const;
 306 };
 307
 308
 309
 310
 311 class TargetLoweringObjectFileELF : public TargetLoweringObjectFile {
 312   bool AtIsCommentChar;  // True if @ is the comment character on this target.
 313   bool HasCrazyBSS;
 314 public:
 315   /// ELF Constructor - AtIsCommentChar is true if the CommentCharacter from TAI
 316   /// is "@".
 317   TargetLoweringObjectFileELF(bool atIsCommentChar = false,
 318                               // FIXME: REMOVE AFTER UNIQUING IS FIXED.
 319                               bool hasCrazyBSS = false)
 320     : AtIsCommentChar(atIsCommentChar), HasCrazyBSS(hasCrazyBSS) {}
 321
 322   virtual void Initialize(MCContext &Ctx, const TargetMachine &TM);
 323
 324
 325   /// getSectionForMergeableConstant - Given a mergeable constant with the
 326   /// specified size and relocation information, return a section that it
 327   /// should be placed in.
 328   virtual const MCSection *
 329   getSectionForMergeableConstant(SectionKind Kind) const;
 330
 331   virtual SectionKind::Kind getKindForNamedSection(const char *Section,
 332                                                    SectionKind::Kind K) const;
 333   void getSectionFlagsAsString(SectionKind Kind,
 334                                SmallVectorImpl<char> &Str) const;
 335
 336   virtual const MCSection *
 337   SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 338                          Mangler *Mang, const TargetMachine &TM) const;
 339 protected:
 340   const MCSection *DataRelSection;
 341   const MCSection *DataRelLocalSection;
 342   const MCSection *DataRelROSection;
 343   const MCSection *DataRelROLocalSection;
 344
 345   const MCSection *MergeableConst4Section;
 346   const MCSection *MergeableConst8Section;
 347   const MCSection *MergeableConst16Section;
 348 };
 349
 350
 351
 352 class TargetLoweringObjectFileMachO : public TargetLoweringObjectFile {
 353   const MCSection *TextCoalSection;
 354   const MCSection *ConstTextCoalSection;
 355   const MCSection *ConstDataCoalSection;
 356   const MCSection *ConstDataSection;
 357   const MCSection *DataCoalSection;
 358   const MCSection *FourByteConstantSection;
 359   const MCSection *EightByteConstantSection;
 360   const MCSection *SixteenByteConstantSection;
 361 public:
 362
 363   virtual void Initialize(MCContext &Ctx, const TargetMachine &TM);
 364
 365   virtual const MCSection *
 366   SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 367                          Mangler *Mang, const TargetMachine &TM) const;
 368
 369   virtual const MCSection *
 370   getSectionForMergeableConstant(SectionKind Kind) const;
 371 };
 372
 373
 374
 375 class TargetLoweringObjectFileCOFF : public TargetLoweringObjectFile {
 376 public:
 377   virtual void Initialize(MCContext &Ctx, const TargetMachine &TM);
 378
 379   virtual void getSectionFlagsAsString(SectionKind Kind,
 380                                        SmallVectorImpl<char> &Str) const;
 381
 382   virtual const MCSection *
 383   SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 384                          Mangler *Mang, const TargetMachine &TM) const;
 385 };
 386
 387 } // end namespace llvm
 388
 389 #endif