move the sectionkind and section classes to TargetLoweringObjectFile.h

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@77681 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 191 insertions, 0 deletions

diff --git a/include/llvm/Target/TargetLoweringObjectFile.h b/include/llvm/Target/TargetLoweringObjectFile.h
index 433a4f9ae3..6b2e91008c 100644
--- a/include/llvm/Target/TargetLoweringObjectFile.h
+++ b/include/llvm/Target/TargetLoweringObjectFile.h
@@ -19,6 +19,197 @@
 #include "llvm/Target/TargetAsmInfo.h"
 
 namespace llvm {
+
+/// SectionKind - This is a simple POD value that classifies the properties of
+/// a section.  A global variable is classified into the deepest possible
+/// classification, and then the target maps them onto their sections based on
+/// what capabilities they have.
+///
+/// The comments below describe these as if they were an inheritance hierarchy
+/// in order to explain the predicates below.
+class SectionKind {
+public:
+  enum Kind {
+    /// Metadata - Debug info sections or other metadata.
+    Metadata,
+    
+    /// Text - Text section, used for functions and other executable code.
+    Text,
+    
+    /// ReadOnly - Data that is never written to at program runtime by the
+    /// program or the dynamic linker.  Things in the top-level readonly
+    /// SectionKind are not mergeable.
+    ReadOnly,
+
+        /// MergeableCString - This is a special section for nul-terminated
+        /// strings.  The linker can unique the C strings, knowing their
+        /// semantics.  Because it uniques based on the nul terminators, the
+        /// compiler can't put strings in this section that have embeded nuls
+        /// in them.
+        MergeableCString,
+    
+        /// MergeableConst - These are sections for merging fixed-length
+        /// constants together.  For example, this can be used to unique
+        /// constant pool entries etc.
+        MergeableConst,
+    
+            /// MergeableConst4 - This is a section used by 4-byte constants,
+            /// for example, floats.
+            MergeableConst4,
+    
+            /// MergeableConst8 - This is a section used by 8-byte constants,
+            /// for example, doubles.
+            MergeableConst8,
+
+            /// MergeableConst16 - This is a section used by 16-byte constants,
+            /// for example, vectors.
+            MergeableConst16,
+    
+    /// Writeable - This is the base of all segments that need to be written
+    /// to during program runtime.
+    
+       /// ThreadLocal - This is the base of all TLS segments.  All TLS
+       /// objects must be writeable, otherwise there is no reason for them to
+       /// be thread local!
+    
+           /// ThreadBSS - Zero-initialized TLS data objects.
+           ThreadBSS,
+    
+           /// ThreadData - Initialized TLS data objects.
+           ThreadData,
+    
+       /// GlobalWriteableData - Writeable data that is global (not thread
+       /// local).
+    
+           /// BSS - Zero initialized writeable data.
+           BSS,
+
+           /// DataRel - This is the most general form of data that is written
+           /// to by the program, it can have random relocations to arbitrary
+           /// globals.
+           DataRel,
+
+               /// DataRelLocal - This is writeable data that has a non-zero
+               /// initializer and has relocations in it, but all of the
+               /// relocations are known to be within the final linked image
+               /// the global is linked into.
+               DataRelLocal,
+
+                   /// DataNoRel - This is writeable data that has a non-zero
+                   /// initializer, but whose initializer is known to have no
+                   /// relocations.
+                   DataNoRel,
+
+           /// ReadOnlyWithRel - These are global variables that are never
+           /// written to by the program, but that have relocations, so they
+           /// must be stuck in a writeable section so that the dynamic linker
+           /// can write to them.  If it chooses to, the dynamic linker can
+           /// mark the pages these globals end up on as read-only after it is
+           /// done with its relocation phase.
+           ReadOnlyWithRel,
+    
+               /// ReadOnlyWithRelLocal - This is data that is readonly by the
+               /// program, but must be writeable so that the dynamic linker
+               /// can perform relocations in it.  This is used when we know
+               /// that all the relocations are to globals in this final
+               /// linked image.
+               ReadOnlyWithRelLocal
+    
+  };
+  
+private:
+  Kind K : 6;
+  
+  /// Weak - This is true if the referenced symbol is weak (i.e. linkonce,
+  /// weak, weak_odr, etc).  This is orthogonal from the categorization.
+  bool Weak : 1;
+  
+  /// ExplicitSection - This is true if the global had a section explicitly
+  /// specified on it.
+  bool ExplicitSection : 1;
+public:
+  
+  // FIXME: REMOVE.
+  Kind getKind() const { return K; }
+  
+  bool isWeak() const { return Weak; }
+  bool hasExplicitSection() const { return ExplicitSection; }
+  
+  
+  bool isMetadata() const { return K == Metadata; }
+  bool isText() const { return K == Text; }
+  
+  bool isReadOnly() const {
+    return K == ReadOnly || K == MergeableCString || isMergeableConst();
+  }
+
+  bool isMergeableCString() const { return K == MergeableCString; }
+  bool isMergeableConst() const {
+    return K == MergeableConst || K == MergeableConst4 ||
+           K == MergeableConst8 || K == MergeableConst16;
+  }
+  
+  bool isMergeableConst4() const { return K == MergeableConst4; }
+  bool isMergeableConst8() const { return K == MergeableConst8; }
+  bool isMergeableConst16() const { return K == MergeableConst16; }
+  
+  bool isWriteable() const {
+    return isThreadLocal() || isGlobalWriteableData();
+  }
+  
+  bool isThreadLocal() const {
+    return K == ThreadData || K == ThreadBSS;
+  }
+  
+  bool isThreadBSS() const { return K == ThreadBSS; } 
+  bool isThreadData() const { return K == ThreadData; } 
+
+  bool isGlobalWriteableData() const {
+    return isBSS() || isDataRel() || isReadOnlyWithRel();
+  }
+  
+  bool isBSS() const { return K == BSS; }
+  
+  bool isDataRel() const {
+    return K == DataRel || K == DataRelLocal || K == DataNoRel;
+  }
+  
+  bool isDataRelLocal() const {
+    return K == DataRelLocal || K == DataNoRel;
+  }
+
+  bool isDataNoRel() const { return K == DataNoRel; }
+  
+  bool isReadOnlyWithRel() const {
+    return K == ReadOnlyWithRel || K == ReadOnlyWithRelLocal;
+  }
+
+  bool isReadOnlyWithRelLocal() const {
+    return K == ReadOnlyWithRelLocal;
+  }
+  
+  static SectionKind get(Kind K, bool isWeak = false,
+                         bool hasExplicitSection = false) {
+    SectionKind Res;
+    Res.K = K;
+    Res.Weak = isWeak;
+    Res.ExplicitSection = hasExplicitSection;
+    return Res;
+  }
+};
+
+class Section {
+public:
+
+  std::string Name;
+  SectionKind Kind;
+
+  explicit Section() { }
+  Section(const std::string &N, SectionKind K) : Name(N), Kind(K) {}
+  const std::string &getName() const { return Name; }
+  SectionKind getKind() const { return Kind; }
+};
+  
   
 class TargetLoweringObjectFile {
 private: