Change SectionKind to be a property that is true of a *section*, it

should have no state that is specific to particular globals in the
section.  In this case, it means the removal of the "isWeak" and
"ExplicitSection" bits.  MCSection uses the new form of SectionKind.

To handle isWeak, I introduced a new SectionInfo class, which is
SectionKind + isWeak, and it is used by the part of the code generator
that does classification of a specific global.

The ExplicitSection disappears.  It is moved onto MCSection as a new
"IsDirective" bit.  Since the Name of a section is either a section
or directive, it makes sense to keep this bit in MCSection.  Ultimately
the creator of MCSection should canonicalize (e.g.) .text to whatever
the actual section is.



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

11 files changed, 242 insertions, 191 deletions

diff --git a/include/llvm/MC/MCSection.h b/include/llvm/MC/MCSection.h
index 5eb8559c90..a622bce838 100644
--- a/include/llvm/MC/MCSection.h
+++ b/include/llvm/MC/MCSection.h
@@ -28,16 +28,27 @@ namespace llvm {
   /// creates these.
   class MCSection {
     std::string Name;
+    
+    /// IsDirective - This is true if the section name is a directive, not
+    /// something that should be printed with ".section".
+    ///
+    /// FIXME: This is a hack.  Switch to a semantic view of the section instead
+    /// of a syntactic one.
+    bool IsDirective;
+    
     MCSection(const MCSection&);      // DO NOT IMPLEMENT
     void operator=(const MCSection&); // DO NOT IMPLEMENT
   protected:
-    MCSection(const StringRef &Name, SectionKind K, MCContext &Ctx);
+    MCSection(const StringRef &Name, bool IsDirective, SectionKind K,
+              MCContext &Ctx);
     SectionKind Kind;
   public:
     virtual ~MCSection();
 
-    static MCSection *Create(const StringRef &Name, SectionKind K,
-                             MCContext &Ctx);
+    bool isDirective() const { return IsDirective; }
+    
+    static MCSection *Create(const StringRef &Name, bool IsDirective, 
+                             SectionKind K, MCContext &Ctx);
     
     const std::string &getName() const { return Name; }
     SectionKind getKind() const { return Kind; }
diff --git a/include/llvm/Target/TargetLoweringObjectFile.h b/include/llvm/Target/TargetLoweringObjectFile.h
index 868b274b30..9961f6a46b 100644
--- a/include/llvm/Target/TargetLoweringObjectFile.h
+++ b/include/llvm/Target/TargetLoweringObjectFile.h
@@ -122,25 +122,14 @@ public:
     
   };
   
-private:
+protected:
   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; }
   
@@ -193,17 +182,42 @@ public:
     return K == ReadOnlyWithRelLocal;
   }
   
-  static SectionKind get(Kind K, bool isWeak = false,
-                         bool hasExplicitSection = false) {
+  static SectionKind get(Kind K) {
     SectionKind Res;
     Res.K = K;
-    Res.Weak = isWeak;
-    Res.ExplicitSection = hasExplicitSection;
     return Res;
   }
 };
 
   
+/// SectionInfo - This class is a target-independent classification of a global
+/// which is used to simplify target-specific code by exposing common
+/// predicates.
+class SectionInfo : public SectionKind {
+  /// 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;
+  
+public:
+  
+  /// Weak - This is true if the referenced symbol is weak (i.e. linkonce,
+  /// weak, weak_odr, etc).  This is orthogonal from the categorization.
+  bool isWeak() const { return Weak; }
+  
+  static SectionInfo get(Kind K, bool isWeak = false) {
+    SectionInfo Res;
+    Res.K = K;
+    Res.Weak = isWeak;
+    return Res;
+  }
+  static SectionInfo get(SectionKind K, bool isWeak = false) {
+    SectionInfo Res;
+    *(SectionKind*)&Res = K;
+    Res.Weak = isWeak;
+    return Res;
+  }
+};
+  
 class TargetLoweringObjectFile {
   MCContext *Ctx;
 protected:
@@ -243,7 +257,7 @@ public:
   // FIXME: NONPUB.
   const MCSection *getOrCreateSection(const char *Name,
                                       bool isDirective,
-                                      SectionKind::Kind K) const;
+                                      SectionKind K) const;
 public:
   
   virtual ~TargetLoweringObjectFile();
@@ -277,8 +291,8 @@ public:
   /// section flags based on the name of the section specified for a global
   /// variable, it can implement this.  This is used on ELF systems so that
   /// ".tbss" gets the TLS bit set etc.
-  virtual SectionKind::Kind getKindForNamedSection(const char *Section,
-                                                   SectionKind::Kind K) const{
+  virtual SectionKind getKindForNamedSection(const char *Section,
+                                             SectionKind K) const {
     return K;
   }
   
@@ -295,7 +309,7 @@ public:
   /// getFlagsForNamedSection.
   virtual const MCSection *
   getSpecialCasedSectionGlobals(const GlobalValue *GV, Mangler *Mang,
-                                SectionKind Kind) const {
+                                SectionInfo Kind) const {
     return 0;
   }
   
@@ -308,7 +322,7 @@ public:
   
 protected:
   virtual const MCSection *
-  SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
+  SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
                          Mangler *Mang, const TargetMachine &TM) const;
 };
   
@@ -335,13 +349,13 @@ public:
   virtual const MCSection *
   getSectionForMergeableConstant(SectionKind Kind) const;
   
-  virtual SectionKind::Kind getKindForNamedSection(const char *Section,
-                                                   SectionKind::Kind K) const;
+  virtual SectionKind getKindForNamedSection(const char *Section,
+                                             SectionKind K) const;
   void getSectionFlagsAsString(SectionKind Kind,
                                SmallVectorImpl<char> &Str) const;
   
   virtual const MCSection *
-  SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
+  SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
                          Mangler *Mang, const TargetMachine &TM) const;
 protected:
   const MCSection *DataRelSection;
@@ -370,7 +384,7 @@ public:
   virtual void Initialize(MCContext &Ctx, const TargetMachine &TM);
 
   virtual const MCSection *
-  SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
+  SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
                          Mangler *Mang, const TargetMachine &TM) const;
   
   virtual const MCSection *
@@ -393,7 +407,7 @@ public:
                                        SmallVectorImpl<char> &Str) const;
   
   virtual const MCSection *
-  SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
+  SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
                          Mangler *Mang, const TargetMachine &TM) const;
 };
 
diff --git a/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
index ebc4b24a04..f6d77309e1 100644
--- a/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
+++ b/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
@@ -151,7 +151,7 @@ void AsmPrinter::SwitchToSection(const MCSection *NS) {
     // If section is named we need to switch into it via special '.section'
     // directive and also append funky flags. Otherwise - section name is just
     // some magic assembler directive.
-    if (NS->getKind().hasExplicitSection()) {
+    if (!NS->isDirective()) {
       SmallString<32> FlagsStr;
       
       getObjFileLowering().getSectionFlagsAsString(NS->getKind(), FlagsStr);
@@ -336,16 +336,16 @@ void AsmPrinter::EmitConstantPool(MachineConstantPool *MCP) {
     SectionKind Kind;
     switch (CPE.getRelocationInfo()) {
     default: llvm_unreachable("Unknown section kind");
-    case 2: Kind = SectionKind::get(SectionKind::ReadOnlyWithRel, false); break;
+    case 2: Kind = SectionKind::get(SectionKind::ReadOnlyWithRel); break;
     case 1:
-      Kind = SectionKind::get(SectionKind::ReadOnlyWithRelLocal,false);
+      Kind = SectionKind::get(SectionKind::ReadOnlyWithRelLocal);
       break;
     case 0:
     switch (TM.getTargetData()->getTypeAllocSize(CPE.getType())) {
-    case 4:  Kind = SectionKind::get(SectionKind::MergeableConst4,false); break;
-    case 8:  Kind = SectionKind::get(SectionKind::MergeableConst8,false); break;
-    case 16: Kind = SectionKind::get(SectionKind::MergeableConst16,false);break;
-    default: Kind = SectionKind::get(SectionKind::MergeableConst,false); break;
+    case 4:  Kind = SectionKind::get(SectionKind::MergeableConst4); break;
+    case 8:  Kind = SectionKind::get(SectionKind::MergeableConst8); break;
+    case 16: Kind = SectionKind::get(SectionKind::MergeableConst16);break;
+    default: Kind = SectionKind::get(SectionKind::MergeableConst); break;
     }
     }
 
@@ -427,8 +427,7 @@ void AsmPrinter::EmitJumpTableInfo(MachineJumpTableInfo *MJTI,
 
   bool JTInDiffSection = false;
   if ((IsPic && !(LoweringInfo && LoweringInfo->usesGlobalOffsetTable())) ||
-      !JumpTableDataSection ||
-      FuncSection->getKind().isWeak()) {
+      !JumpTableDataSection || F->isWeakForLinker()) {
     // In PIC mode, we need to emit the jump table to the same section as the
     // function body itself, otherwise the label differences won't make sense.
     // We should also do if the section name is NULL or function is declared in
diff --git a/lib/CodeGen/ELFWriter.cpp b/lib/CodeGen/ELFWriter.cpp
index c7438329e3..1d33c7e1fe 100644
--- a/lib/CodeGen/ELFWriter.cpp
+++ b/lib/CodeGen/ELFWriter.cpp
@@ -188,16 +188,16 @@ ELFSection &ELFWriter::getConstantPoolSection(MachineConstantPoolEntry &CPE) {
   SectionKind Kind;
   switch (CPE.getRelocationInfo()) {
   default: llvm_unreachable("Unknown section kind");
-  case 2: Kind = SectionKind::get(SectionKind::ReadOnlyWithRel,false); break;
+  case 2: Kind = SectionKind::get(SectionKind::ReadOnlyWithRel); break;
   case 1:
-    Kind = SectionKind::get(SectionKind::ReadOnlyWithRelLocal,false);
+    Kind = SectionKind::get(SectionKind::ReadOnlyWithRelLocal);
     break;
   case 0:
     switch (TM.getTargetData()->getTypeAllocSize(CPE.getType())) {
-    case 4:  Kind = SectionKind::get(SectionKind::MergeableConst4,false); break;
-    case 8:  Kind = SectionKind::get(SectionKind::MergeableConst8,false); break;
-    case 16: Kind = SectionKind::get(SectionKind::MergeableConst16,false);break;
-    default: Kind = SectionKind::get(SectionKind::MergeableConst,false); break;
+    case 4:  Kind = SectionKind::get(SectionKind::MergeableConst4); break;
+    case 8:  Kind = SectionKind::get(SectionKind::MergeableConst8); break;
+    case 16: Kind = SectionKind::get(SectionKind::MergeableConst16); break;
+    default: Kind = SectionKind::get(SectionKind::MergeableConst); break;
     }
   }
 
diff --git a/lib/MC/MCSection.cpp b/lib/MC/MCSection.cpp
index 006546febb..84487b24be 100644
--- a/lib/MC/MCSection.cpp
+++ b/lib/MC/MCSection.cpp
@@ -14,15 +14,16 @@ using namespace llvm;
 MCSection::~MCSection() {
 }
 
-MCSection::MCSection(const StringRef &N, SectionKind K, MCContext &Ctx)
-  : Name(N), Kind(K) {
+MCSection::MCSection(const StringRef &N, bool isDirective, SectionKind K, 
+                     MCContext &Ctx)
+  : Name(N), IsDirective(isDirective), Kind(K) {
   MCSection *&Entry = Ctx.Sections[Name];
   assert(Entry == 0 && "Multiple sections with the same name created");
   Entry = this;
 }
 
-MCSection *MCSection::Create(const StringRef &Name, SectionKind K,
-                             MCContext &Ctx) {
-  return new (Ctx) MCSection(Name, K, Ctx);
+MCSection *MCSection::Create(const StringRef &Name, bool IsDirective, 
+                             SectionKind K, MCContext &Ctx) {
+  return new (Ctx) MCSection(Name, IsDirective, K, Ctx);
 }
 
diff --git a/lib/Target/Alpha/AlphaISelLowering.cpp b/lib/Target/Alpha/AlphaISelLowering.cpp
index c5f24dc02b..001723a2fa 100644
--- a/lib/Target/Alpha/AlphaISelLowering.cpp
+++ b/lib/Target/Alpha/AlphaISelLowering.cpp
@@ -36,8 +36,10 @@ class TargetLoweringObjectFileAlpha : public TargetLoweringObjectFile {
 public:
   void Initialize(MCContext &Ctx, const TargetMachine &TM) {
     TargetLoweringObjectFile::Initialize(Ctx, TM);
-    TextSection = getOrCreateSection("_text", true, SectionKind::Text);
-    DataSection = getOrCreateSection("_data", true, SectionKind::DataRel);
+    TextSection = getOrCreateSection("_text", true, 
+                                     SectionKind::get(SectionKind::Text));
+    DataSection = getOrCreateSection("_data", true, 
+                                     SectionKind::get(SectionKind::DataRel));
   }
 };
 }
diff --git a/lib/Target/PIC16/PIC16AsmPrinter.cpp b/lib/Target/PIC16/PIC16AsmPrinter.cpp
index 604d1050d4..596ec7a32b 100644
--- a/lib/Target/PIC16/PIC16AsmPrinter.cpp
+++ b/lib/Target/PIC16/PIC16AsmPrinter.cpp
@@ -73,7 +73,7 @@ bool PIC16AsmPrinter::runOnMachineFunction(MachineFunction &MF) {
  
   const MCSection *fCodeSection = 
     getObjFileLowering().getOrCreateSection(codeSection, false, 
-                                            SectionKind::Text);
+                                           SectionKind::get(SectionKind::Text));
   // Start the Code Section.
   O <<  "\n";
   SwitchToSection(fCodeSection);
@@ -350,7 +350,7 @@ void PIC16AsmPrinter::EmitFunctionFrame(MachineFunction &MF) {
 
   const MCSection *fPDataSection =
     getObjFileLowering().getOrCreateSection(SectionName, false,
-                                            SectionKind::DataRel);
+                                        SectionKind::get(SectionKind::DataRel));
   SwitchToSection(fPDataSection);
   
   // Emit function frame label
diff --git a/lib/Target/PIC16/PIC16TargetObjectFile.cpp b/lib/Target/PIC16/PIC16TargetObjectFile.cpp
index 5a2d4d8896..91e98b268d 100644
--- a/lib/Target/PIC16/PIC16TargetObjectFile.cpp
+++ b/lib/Target/PIC16/PIC16TargetObjectFile.cpp
@@ -19,24 +19,27 @@ void PIC16TargetObjectFile::Initialize(MCContext &Ctx, const TargetMachine &tm){
   TargetLoweringObjectFile::Initialize(Ctx, tm);
   TM = &tm;
   
-  BSSSection_  = getOrCreateSection("udata.# UDATA", false, SectionKind::BSS);
+  BSSSection_  = getOrCreateSection("udata.# UDATA", false, 
+                                    SectionKind::get(SectionKind::BSS));
   ReadOnlySection = getOrCreateSection("romdata.# ROMDATA", false,
-                                       SectionKind::ReadOnly);
-  DataSection = getOrCreateSection("idata.# IDATA", false,SectionKind::DataRel);
+                                       SectionKind::get(SectionKind::ReadOnly));
+  DataSection = getOrCreateSection("idata.# IDATA", false,
+                                   SectionKind::get(SectionKind::DataRel));
   
   // Need because otherwise a .text symbol is emitted by DwarfWriter
   // in BeginModule, and gpasm cribbs for that .text symbol.
-  TextSection = getOrCreateSection("", true, SectionKind::Text);
+  TextSection = getOrCreateSection("", true,
+                                   SectionKind::get(SectionKind::Text));
 
   ROSections.push_back(new PIC16Section(ReadOnlySection));
   
   // FIXME: I don't know what the classification of these sections really is.
   ExternalVarDecls = new PIC16Section(getOrCreateSection("ExternalVarDecls",
                                                          false,
-                                                        SectionKind::Metadata));
+                                      SectionKind::get(SectionKind::Metadata)));
   ExternalVarDefs = new PIC16Section(getOrCreateSection("ExternalVarDefs",
                                                         false,
-                                                        SectionKind::Metadata));
+                                      SectionKind::get(SectionKind::Metadata)));
 }
 
 
@@ -66,7 +69,7 @@ PIC16TargetObjectFile::getBSSSectionForGlobal(const GlobalVariable *GV) const {
     std::string name = PAN::getUdataSectionName(BSSSections.size());
     const MCSection *NewSection = getOrCreateSection(name.c_str(), false,
                                                      // FIXME.
-                                                     SectionKind::Metadata);
+                                       SectionKind::get(SectionKind::Metadata));
 
     FoundBSS = new PIC16Section(NewSection);
 
@@ -108,7 +111,7 @@ PIC16TargetObjectFile::getIDATASectionForGlobal(const GlobalVariable *GV) const{
     std::string name = PAN::getIdataSectionName(IDATASections.size());
     const MCSection *NewSection = getOrCreateSection(name.c_str(), false,
                                                    // FIXME.
-                                                   SectionKind::Metadata);
+                                       SectionKind::get(SectionKind::Metadata));
 
     FoundIDATA = new PIC16Section(NewSection);
 
@@ -144,7 +147,7 @@ PIC16TargetObjectFile::getSectionForAuto(const GlobalVariable *GV) const {
     const MCSection *NewSection = getOrCreateSection(name.c_str(),
                                                      // FIXME.
                                                      false,
-                                                     SectionKind::Metadata);
+                                       SectionKind::get(SectionKind::Metadata));
 
     FoundAutoSec = new PIC16Section(NewSection);
 
@@ -163,14 +166,14 @@ PIC16TargetObjectFile::getSectionForAuto(const GlobalVariable *GV) const {
 // multiple data sections if required.
 const MCSection *
 PIC16TargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV1,
-                                              SectionKind Kind,
+                                              SectionInfo Info,
                                               Mangler *Mang,
                                               const TargetMachine &TM) const {
   // We select the section based on the initializer here, so it really
   // has to be a GlobalVariable.
   const GlobalVariable *GV = dyn_cast<GlobalVariable>(GV1); 
   if (!GV)
-    return TargetLoweringObjectFile::SelectSectionForGlobal(GV1, Kind, Mang,TM);
+    return TargetLoweringObjectFile::SelectSectionForGlobal(GV1, Info, Mang,TM);
 
   // Record External Var Decls.
   if (GV->isDeclaration()) {
@@ -204,7 +207,7 @@ PIC16TargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV1,
     return getROSectionForGlobal(GV);
 
   // Else let the default implementation take care of it.
-  return TargetLoweringObjectFile::SelectSectionForGlobal(GV, Kind, Mang,TM);
+  return TargetLoweringObjectFile::SelectSectionForGlobal(GV, Info, Mang,TM);
 }
 
 PIC16TargetObjectFile::~PIC16TargetObjectFile() {
@@ -226,7 +229,7 @@ PIC16TargetObjectFile::~PIC16TargetObjectFile() {
 const MCSection *
 PIC16TargetObjectFile::getSpecialCasedSectionGlobals(const GlobalValue *GV,
                                                      Mangler *Mang,
-                                                     SectionKind Kind) const {
+                                                     SectionInfo Info) const {
   // If GV has a sectin name or section address create that section now.
   if (GV->hasSection()) {
     if (const GlobalVariable *GVar = cast<GlobalVariable>(GV)) {
@@ -297,7 +300,7 @@ PIC16TargetObjectFile::CreateBSSSectionForGlobal(const GlobalVariable *GV,
   PIC16Section *NewBSS = FoundBSS;
   if (NewBSS == NULL) {
     const MCSection *NewSection = getOrCreateSection(Name.c_str(), false,
-                                                     SectionKind::BSS);
+                                            SectionKind::get(SectionKind::BSS));
     NewBSS = new PIC16Section(NewSection);
     BSSSections.push_back(NewBSS);
   }
@@ -350,7 +353,7 @@ PIC16TargetObjectFile::CreateIDATASectionForGlobal(const GlobalVariable *GV,
   if (NewIDATASec == NULL) {
     const MCSection *NewSection = getOrCreateSection(Name.c_str(), false,
                                                    // FIXME:
-                                                   SectionKind::Metadata);
+                                       SectionKind::get(SectionKind::Metadata));
     NewIDATASec = new PIC16Section(NewSection);
     IDATASections.push_back(NewIDATASec);
   }
@@ -389,7 +392,7 @@ PIC16TargetObjectFile::CreateROSectionForGlobal(const GlobalVariable *GV,
   PIC16Section *NewRomSec = FoundROSec;
   if (NewRomSec == NULL) {
     const MCSection *NewSection = getOrCreateSection(Name.c_str(), false,
-                                                     SectionKind::ReadOnly);
+                                       SectionKind::get(SectionKind::ReadOnly));
     NewRomSec = new PIC16Section(NewSection);
     ROSections.push_back(NewRomSec);
   }
diff --git a/lib/Target/PIC16/PIC16TargetObjectFile.h b/lib/Target/PIC16/PIC16TargetObjectFile.h
index c296954dce..831f924572 100644
--- a/lib/Target/PIC16/PIC16TargetObjectFile.h
+++ b/lib/Target/PIC16/PIC16TargetObjectFile.h
@@ -62,9 +62,9 @@ namespace llvm {
     /// section assignment of a global.
     virtual const MCSection *
     getSpecialCasedSectionGlobals(const GlobalValue *GV, Mangler *Mang,
-                                  SectionKind Kind) const;
+                                  SectionInfo Info) const;
     virtual const MCSection *SelectSectionForGlobal(const GlobalValue *GV,
-                                                    SectionKind Kind,
+                                                    SectionInfo Info,
                                                     Mangler *Mang,
                                                     const TargetMachine&) const;
   private:
diff --git a/lib/Target/TargetLoweringObjectFile.cpp b/lib/Target/TargetLoweringObjectFile.cpp
index 025e3f21b7..b9e585d6dd 100644
--- a/lib/Target/TargetLoweringObjectFile.cpp
+++ b/lib/Target/TargetLoweringObjectFile.cpp
@@ -81,26 +81,31 @@ static bool isConstantString(const Constant *C) {
   return false;
 }
 
-static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV,
-                                              const TargetMachine &TM) {
+/// SectionKindForGlobal - This is a top-level target-independent classifier for
+/// a global variable.  Given an global variable and information from TM, it
+/// classifies the global in a variety of ways that make various target
+/// implementations simpler.  The target implementation is free to ignore this
+/// extra info of course.
+static SectionKind SectionKindForGlobal(const GlobalValue *GV,
+                                        const TargetMachine &TM) {
   Reloc::Model ReloModel = TM.getRelocationModel();
   
   // Early exit - functions should be always in text sections.
   const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
   if (GVar == 0)
-    return SectionKind::Text;
+    return SectionKind::get(SectionKind::Text);
 
   
   // Handle thread-local data first.
   if (GVar->isThreadLocal()) {
     if (isSuitableForBSS(GVar))
-      return SectionKind::ThreadBSS;
-    return SectionKind::ThreadData;
+      return SectionKind::get(SectionKind::ThreadBSS);
+    return SectionKind::get(SectionKind::ThreadData);
   }
 
   // Variable can be easily put to BSS section.
   if (isSuitableForBSS(GVar))
-    return SectionKind::BSS;
+    return SectionKind::get(SectionKind::BSS);
 
   Constant *C = GVar->getInitializer();
   
@@ -116,16 +121,16 @@ static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV,
       // If initializer is a null-terminated string, put it in a "cstring"
       // section if the target has it.
       if (isConstantString(C))
-        return SectionKind::MergeableCString;
+        return SectionKind::get(SectionKind::MergeableCString);
       
       // Otherwise, just drop it into a mergable constant section.  If we have
       // a section for this size, use it, otherwise use the arbitrary sized
       // mergable section.
       switch (TM.getTargetData()->getTypeAllocSize(C->getType())) {
-      case 4:  return SectionKind::MergeableConst4;
-      case 8:  return SectionKind::MergeableConst8;
-      case 16: return SectionKind::MergeableConst16;
-      default: return SectionKind::MergeableConst;
+      case 4:  return SectionKind::get(SectionKind::MergeableConst4);
+      case 8:  return SectionKind::get(SectionKind::MergeableConst8);
+      case 16: return SectionKind::get(SectionKind::MergeableConst16);
+      default: return SectionKind::get(SectionKind::MergeableConst);
       }
       
     case Constant::LocalRelocation:
@@ -135,11 +140,11 @@ static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV,
       // the linker doesn't take relocations into consideration when it tries to
       // merge entries in the section.
       if (ReloModel == Reloc::Static)
-        return SectionKind::ReadOnly;
+        return SectionKind::get(SectionKind::ReadOnly);
               
       // Otherwise, the dynamic linker needs to fix it up, put it in the
       // writable data.rel.local section.
-      return SectionKind::ReadOnlyWithRelLocal;
+      return SectionKind::get(SectionKind::ReadOnlyWithRelLocal);
               
     case Constant::GlobalRelocations:
       // In static relocation model, the linker will resolve all addresses, so
@@ -148,11 +153,11 @@ static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV,
       // the linker doesn't take relocations into consideration when it tries to
       // merge entries in the section.
       if (ReloModel == Reloc::Static)
-        return SectionKind::ReadOnly;
+        return SectionKind::get(SectionKind::ReadOnly);
       
       // Otherwise, the dynamic linker needs to fix it up, put it in the
       // writable data.rel section.
-      return SectionKind::ReadOnlyWithRel;
+      return SectionKind::get(SectionKind::ReadOnlyWithRel);
     }
   }
 
@@ -162,16 +167,16 @@ static SectionKind::Kind SectionKindForGlobal(const GlobalValue *GV,
   // globals together onto fewer pages, improving the locality of the dynamic
   // linker.
   if (ReloModel == Reloc::Static)
-    return SectionKind::DataNoRel;
+    return SectionKind::get(SectionKind::DataNoRel);
 
   switch (C->getRelocationInfo()) {
   default: llvm_unreachable("unknown relocation info kind");
   case Constant::NoRelocation:
-    return SectionKind::DataNoRel;
+    return SectionKind::get(SectionKind::DataNoRel);
   case Constant::LocalRelocation:
-    return SectionKind::DataRelLocal;
+    return SectionKind::get(SectionKind::DataRelLocal);
   case Constant::GlobalRelocations:
-    return SectionKind::DataRel;
+    return SectionKind::get(SectionKind::DataRel);
   }
 }
 
@@ -184,47 +189,44 @@ SectionForGlobal(const GlobalValue *GV, Mangler *Mang,
   assert(!GV->isDeclaration() && !GV->hasAvailableExternallyLinkage() &&
          "Can only be used for global definitions");
   
-  SectionKind::Kind GVKind = SectionKindForGlobal(GV, TM);
+  SectionKind Kind = SectionKindForGlobal(GV, TM);
+  SectionInfo Info = SectionInfo::get(Kind, GV->isWeakForLinker());
   
-  SectionKind Kind = SectionKind::get(GVKind, GV->isWeakForLinker(),
-                                      GV->hasSection());
-
-
   // Select section name.
   if (GV->hasSection()) {
     // If the target has special section hacks for specifically named globals,
     // return them now.
-    if (const MCSection *TS = getSpecialCasedSectionGlobals(GV, Mang, Kind))
+    if (const MCSection *TS = getSpecialCasedSectionGlobals(GV, Mang, Info))
       return TS;
     
     // If the target has magic semantics for certain section names, make sure to
     // pick up the flags.  This allows the user to write things with attribute
     // section and still get the appropriate section flags printed.
-    GVKind = getKindForNamedSection(GV->getSection().c_str(), GVKind);
+    Kind = getKindForNamedSection(GV->getSection().c_str(), Kind);
     
-    return getOrCreateSection(GV->getSection().c_str(), false, GVKind);
+    return getOrCreateSection(GV->getSection().c_str(), false, Kind);
   }
 
   
   // Use default section depending on the 'type' of global
-  return SelectSectionForGlobal(GV, Kind, Mang, TM);
+  return SelectSectionForGlobal(GV, Info, Mang, TM);
 }
 
 // Lame default implementation. Calculate the section name for global.
 const MCSection *
 TargetLoweringObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
-                                                 SectionKind Kind,
+                                                 SectionInfo Info,
                                                  Mangler *Mang,
                                                  const TargetMachine &TM) const{
-  assert(!Kind.isThreadLocal() && "Doesn't support TLS");
+  assert(!Info.isThreadLocal() && "Doesn't support TLS");
   
-  if (Kind.isText())
+  if (Info.isText())
     return getTextSection();
   
-  if (Kind.isBSS() && BSSSection_ != 0)
+  if (Info.isBSS() && BSSSection_ != 0)
     return BSSSection_;
   
-  if (Kind.isReadOnly() && ReadOnlySection != 0)
+  if (Info.isReadOnly() && ReadOnlySection != 0)
     return ReadOnlySection;
 
   return getDataSection();
@@ -244,12 +246,10 @@ getSectionForMergeableConstant(SectionKind Kind) const {
 
 
 const MCSection *TargetLoweringObjectFile::
-getOrCreateSection(const char *Name, bool isDirective,
-                   SectionKind::Kind Kind) const {
+getOrCreateSection(const char *Name, bool isDirective, SectionKind Kind) const {
   if (MCSection *S = Ctx->GetSection(Name))
     return S;
-  SectionKind K = SectionKind::get(Kind, false /*weak*/, !isDirective);
-  return MCSection::Create(Name, K, *Ctx);
+  return MCSection::Create(Name, isDirective, Kind, *Ctx);
 }
 
 
@@ -262,45 +262,55 @@ void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
                                              const TargetMachine &TM) {
   TargetLoweringObjectFile::Initialize(Ctx, TM);
   if (!HasCrazyBSS)
-    BSSSection_ = getOrCreateSection("\t.bss", true, SectionKind::BSS);
+    BSSSection_ = getOrCreateSection("\t.bss", true,
+                                     SectionKind::get(SectionKind::BSS));
   else
     // PPC/Linux doesn't support the .bss directive, it needs .section .bss.
     // FIXME: Does .section .bss work everywhere??
-    BSSSection_ = getOrCreateSection("\t.bss", false, SectionKind::BSS);
+    // FIXME2: this should just be handle by the section printer.  We should get
+    // away from syntactic view of the sections and MCSection should just be a
+    // semantic view.
+    BSSSection_ = getOrCreateSection("\t.bss", false,
+                                     SectionKind::get(SectionKind::BSS));
 
     
-  TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
-  DataSection = getOrCreateSection("\t.data", true, SectionKind::DataRel);
+  TextSection = getOrCreateSection("\t.text", true,
+                                   SectionKind::get(SectionKind::Text));
+  DataSection = getOrCreateSection("\t.data", true,
+                                   SectionKind::get(SectionKind::DataRel));
   ReadOnlySection =
-    getOrCreateSection("\t.rodata", false, SectionKind::ReadOnly);
+    getOrCreateSection("\t.rodata", false,
+                       SectionKind::get(SectionKind::ReadOnly));
   TLSDataSection =
-    getOrCreateSection("\t.tdata", false, SectionKind::ThreadData);
+    getOrCreateSection("\t.tdata", false,
+                       SectionKind::get(SectionKind::ThreadData));
   CStringSection_ = getOrCreateSection("\t.rodata.str", true,
-                                       SectionKind::MergeableCString);
+                               SectionKind::get(SectionKind::MergeableCString));
 
-  TLSBSSSection = getOrCreateSection("\t.tbss", false, SectionKind::ThreadBSS);
+  TLSBSSSection = getOrCreateSection("\t.tbss", false, 
+                                     SectionKind::get(SectionKind::ThreadBSS));
 
   DataRelSection = getOrCreateSection("\t.data.rel", false,
-                                      SectionKind::DataRel);
+                                      SectionKind::get(SectionKind::DataRel));
   DataRelLocalSection = getOrCreateSection("\t.data.rel.local", false,
-                                           SectionKind::DataRelLocal);
+                                   SectionKind::get(SectionKind::DataRelLocal));
   DataRelROSection = getOrCreateSection("\t.data.rel.ro", false,
-                                        SectionKind::ReadOnlyWithRel);
+                                SectionKind::get(SectionKind::ReadOnlyWithRel));
   DataRelROLocalSection =
     getOrCreateSection("\t.data.rel.ro.local", false,
-                       SectionKind::ReadOnlyWithRelLocal);
+                       SectionKind::get(SectionKind::ReadOnlyWithRelLocal));
     
   MergeableConst4Section = getOrCreateSection(".rodata.cst4", false,
-                                              SectionKind::MergeableConst4);
+                                SectionKind::get(SectionKind::MergeableConst4));
   MergeableConst8Section = getOrCreateSection(".rodata.cst8", false,
-                                              SectionKind::MergeableConst8);
+                                SectionKind::get(SectionKind::MergeableConst8));
   MergeableConst16Section = getOrCreateSection(".rodata.cst16", false,
-                                               SectionKind::MergeableConst16);
+                               SectionKind::get(SectionKind::MergeableConst16));
 }
 
 
-SectionKind::Kind TargetLoweringObjectFileELF::
-getKindForNamedSection(const char *Name, SectionKind::Kind K) const {
+SectionKind TargetLoweringObjectFileELF::
+getKindForNamedSection(const char *Name, SectionKind K) const {
   if (Name[0] != '.') return K;
   
   // Some lame default implementation based on some magic section names.
@@ -308,19 +318,19 @@ getKindForNamedSection(const char *Name, SectionKind::Kind K) const {
       strncmp(Name, ".llvm.linkonce.b.", 17) == 0 ||
       strncmp(Name, ".gnu.linkonce.sb.", 17) == 0 ||
       strncmp(Name, ".llvm.linkonce.sb.", 18) == 0)
-    return SectionKind::BSS;
+    return SectionKind::get(SectionKind::BSS);
   
   if (strcmp(Name, ".tdata") == 0 ||
       strncmp(Name, ".tdata.", 7) == 0 ||
       strncmp(Name, ".gnu.linkonce.td.", 17) == 0 ||
       strncmp(Name, ".llvm.linkonce.td.", 18) == 0)
-    return SectionKind::ThreadData;
+    return SectionKind::get(SectionKind::ThreadData);
   
   if (strcmp(Name, ".tbss") == 0 ||