diff --git a/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
index ebc4b24..f6d7730 100644
--- a/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
+++ b/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
@@ -151,7 +151,7 @@
     // 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 @@
     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 @@
 
   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 c743832..1d33c7e 100644
--- a/lib/CodeGen/ELFWriter.cpp
+++ b/lib/CodeGen/ELFWriter.cpp
@@ -188,16 +188,16 @@
   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 006546f..84487b2 100644
--- a/lib/MC/MCSection.cpp
+++ b/lib/MC/MCSection.cpp
@@ -14,15 +14,16 @@
 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 c5f24dc..001723a2 100644
--- a/lib/Target/Alpha/AlphaISelLowering.cpp
+++ b/lib/Target/Alpha/AlphaISelLowering.cpp
@@ -36,8 +36,10 @@
 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 604d105..596ec7a 100644
--- a/lib/Target/PIC16/PIC16AsmPrinter.cpp
+++ b/lib/Target/PIC16/PIC16AsmPrinter.cpp
@@ -73,7 +73,7 @@
  
   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 @@
 
   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 5a2d4d8..91e98b2 100644
--- a/lib/Target/PIC16/PIC16TargetObjectFile.cpp
+++ b/lib/Target/PIC16/PIC16TargetObjectFile.cpp
@@ -19,24 +19,27 @@
   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 @@
     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 @@
     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 @@
     const MCSection *NewSection = getOrCreateSection(name.c_str(),
                                                      // FIXME.
                                                      false,
-                                                     SectionKind::Metadata);
+                                       SectionKind::get(SectionKind::Metadata));
 
     FoundAutoSec = new PIC16Section(NewSection);
 
@@ -163,14 +166,14 @@
 // 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 @@
     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 @@
 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 @@
   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 @@
   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 @@
   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 c296954..831f924 100644
--- a/lib/Target/PIC16/PIC16TargetObjectFile.h
+++ b/lib/Target/PIC16/PIC16TargetObjectFile.h
@@ -62,9 +62,9 @@
     /// 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 025e3f2..b9e585d 100644
--- a/lib/Target/TargetLoweringObjectFile.cpp
+++ b/lib/Target/TargetLoweringObjectFile.cpp
@@ -81,26 +81,31 @@
   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 @@
       // 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 @@
       // 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 @@
       // 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 @@
   // 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 @@
   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 @@
 
 
 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 @@
                                              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 @@
       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 ||
       strncmp(Name, ".tbss.", 6) == 0 ||
       strncmp(Name, ".gnu.linkonce.tb.", 17) == 0 ||
       strncmp(Name, ".llvm.linkonce.tb.", 18) == 0)
-    return SectionKind::ThreadBSS;
+    return SectionKind::get(SectionKind::ThreadBSS);
   
   return K;
 }
@@ -400,20 +410,20 @@
 }
 
 const MCSection *TargetLoweringObjectFileELF::
-SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
+SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Info,
                        Mangler *Mang, const TargetMachine &TM) const {
   
   // If this global is linkonce/weak and the target handles this by emitting it
   // into a 'uniqued' section name, create and return the section now.
-  if (Kind.isWeak()) {
-    const char *Prefix = getSectionPrefixForUniqueGlobal(Kind);
+  if (Info.isWeak()) {
+    const char *Prefix = getSectionPrefixForUniqueGlobal(Info);
     std::string Name = Mang->makeNameProper(GV->getNameStr());
-    return getOrCreateSection((Prefix+Name).c_str(), false, Kind.getKind());
+    return getOrCreateSection((Prefix+Name).c_str(), false, Info);
   }
   
-  if (Kind.isText()) return TextSection;
+  if (Info.isText()) return TextSection;
   
-  if (Kind.isMergeableCString()) {
+  if (Info.isMergeableCString()) {
    assert(CStringSection_ && "Should have string section prefix");
     
     // We also need alignment here.
@@ -424,32 +434,32 @@
     
     std::string Name = CStringSection_->getName() + "1." + utostr(Align);
     return getOrCreateSection(Name.c_str(), false,
-                              SectionKind::MergeableCString);
+                              SectionKind::get(SectionKind::MergeableCString));
   }
   
-  if (Kind.isMergeableConst()) {
-    if (Kind.isMergeableConst4())
+  if (Info.isMergeableConst()) {
+    if (Info.isMergeableConst4())
       return MergeableConst4Section;
-    if (Kind.isMergeableConst8())
+    if (Info.isMergeableConst8())
       return MergeableConst8Section;
-    if (Kind.isMergeableConst16())
+    if (Info.isMergeableConst16())
       return MergeableConst16Section;
     return ReadOnlySection;  // .const
   }
   
-  if (Kind.isReadOnly())             return ReadOnlySection;
+  if (Info.isReadOnly())             return ReadOnlySection;
   
-  if (Kind.isThreadData())           return TLSDataSection;
-  if (Kind.isThreadBSS())            return TLSBSSSection;
+  if (Info.isThreadData())           return TLSDataSection;
+  if (Info.isThreadBSS())            return TLSBSSSection;
   
-  if (Kind.isBSS())                  return BSSSection_;
+  if (Info.isBSS())                  return BSSSection_;
   
-  if (Kind.isDataNoRel())            return DataSection;
-  if (Kind.isDataRelLocal())         return DataRelLocalSection;
-  if (Kind.isDataRel())              return DataRelSection;
-  if (Kind.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
+  if (Info.isDataNoRel())            return DataSection;
+  if (Info.isDataRelLocal())         return DataRelLocalSection;
+  if (Info.isDataRel())              return DataRelSection;
+  if (Info.isReadOnlyWithRelLocal()) return DataRelROLocalSection;
   
-  assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
+  assert(Info.isReadOnlyWithRel() && "Unknown section kind");
   return DataRelROSection;
 }
 
@@ -479,58 +489,65 @@
 void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
                                                const TargetMachine &TM) {
   TargetLoweringObjectFile::Initialize(Ctx, TM);
-  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));
   
   CStringSection_ = getOrCreateSection("\t.cstring", true,
-                                       SectionKind::MergeableCString);
+                               SectionKind::get(SectionKind::MergeableCString));
   FourByteConstantSection = getOrCreateSection("\t.literal4\n", true,
-                                               SectionKind::MergeableConst4);
+                                SectionKind::get(SectionKind::MergeableConst4));
   EightByteConstantSection = getOrCreateSection("\t.literal8\n", true,
-                                                SectionKind::MergeableConst8);
+                                SectionKind::get(SectionKind::MergeableConst8));
   
   // ld_classic doesn't support .literal16 in 32-bit mode, and ld64 falls back
   // to using it in -static mode.
   if (TM.getRelocationModel() != Reloc::Static &&
       TM.getTargetData()->getPointerSize() == 32)
     SixteenByteConstantSection = 
-      getOrCreateSection("\t.literal16\n", true, SectionKind::MergeableConst16);
+      getOrCreateSection("\t.literal16\n", true, 
+                         SectionKind::get(SectionKind::MergeableConst16));
   else
     SixteenByteConstantSection = 0;
   
-  ReadOnlySection = getOrCreateSection("\t.const", true, SectionKind::ReadOnly);
+  ReadOnlySection = getOrCreateSection("\t.const", true, 
+                                       SectionKind::get(SectionKind::ReadOnly));
   
   TextCoalSection =
   getOrCreateSection("\t__TEXT,__textcoal_nt,coalesced,pure_instructions",
-                     false, SectionKind::Text);
+                     false, SectionKind::get(SectionKind::Text));
   ConstTextCoalSection = getOrCreateSection("\t__TEXT,__const_coal,coalesced",
-                                            false, SectionKind::Text);
+                                            false,
+                                           SectionKind::get(SectionKind::Text));
   ConstDataCoalSection = getOrCreateSection("\t__DATA,__const_coal,coalesced",
-                                            false, SectionKind::Text);
+                                            false, 
+                                          SectionKind::get(SectionKind::Text));
   ConstDataSection = getOrCreateSection("\t.const_data", true,
-                                        SectionKind::ReadOnlyWithRel);
+                                SectionKind::get(SectionKind::ReadOnlyWithRel));
   DataCoalSection = getOrCreateSection("\t__DATA,__datacoal_nt,coalesced",
-                                       false, SectionKind::DataRel);
+                                       false,
+                                       SectionKind::get(SectionKind::DataRel));
 }
 
 const MCSection *TargetLoweringObjectFileMachO::
-SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
+SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Info,
                        Mangler *Mang, const TargetMachine &TM) const {
-  assert(!Kind.isThreadLocal() && "Darwin doesn't support TLS");
+  assert(!Info.isThreadLocal() && "Darwin doesn't support TLS");
   
-  if (Kind.isText())
-    return Kind.isWeak() ? TextCoalSection : TextSection;
+  if (Info.isText())
+    return Info.isWeak() ? TextCoalSection : TextSection;
   
   // If this is weak/linkonce, put this in a coalescable section, either in text
   // or data depending on if it is writable.
-  if (Kind.isWeak()) {
-    if (Kind.isReadOnly())
+  if (Info.isWeak()) {
+    if (Info.isReadOnly())
       return ConstTextCoalSection;
     return DataCoalSection;
   }
   
   // FIXME: Alignment check should be handled by section classifier.
-  if (Kind.isMergeableCString()) {
+  if (Info.isMergeableCString()) {
     Constant *C = cast<GlobalVariable>(GV)->getInitializer();
     const Type *Ty = cast<ArrayType>(C->getType())->getElementType();
     const TargetData &TD = *TM.getTargetData();
@@ -544,24 +561,24 @@
     return ReadOnlySection;
   }
   
-  if (Kind.isMergeableConst()) {
-    if (Kind.isMergeableConst4())
+  if (Info.isMergeableConst()) {
+    if (Info.isMergeableConst4())
       return FourByteConstantSection;
-    if (Kind.isMergeableConst8())
+    if (Info.isMergeableConst8())
       return EightByteConstantSection;
-    if (Kind.isMergeableConst16() && SixteenByteConstantSection)
+    if (Info.isMergeableConst16() && SixteenByteConstantSection)
       return SixteenByteConstantSection;
     return ReadOnlySection;  // .const
   }
   
   // FIXME: ROData -> const in -static mode that is relocatable but they happen
   // by the static linker.  Why not mergeable?
-  if (Kind.isReadOnly())
+  if (Info.isReadOnly())
     return ReadOnlySection;
 
   // If this is marked const, put it into a const section.  But if the dynamic
   // linker needs to write to it, put it in the data segment.
-  if (Kind.isReadOnlyWithRel())
+  if (Info.isReadOnlyWithRel())
     return ConstDataSection;
   
   // Otherwise, just drop the variable in the normal data section.
@@ -615,8 +632,10 @@
 void TargetLoweringObjectFileCOFF::Initialize(MCContext &Ctx,
                                               const TargetMachine &TM) {
   TargetLoweringObjectFile::Initialize(Ctx, TM);
-  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));
 }
 
 void TargetLoweringObjectFileCOFF::
@@ -642,26 +661,25 @@
 
 
 const MCSection *TargetLoweringObjectFileCOFF::
-SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
+SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Info,
                        Mangler *Mang, const TargetMachine &TM) const {
-  assert(!Kind.isThreadLocal() && "Doesn't support TLS");
+  assert(!Info.isThreadLocal() && "Doesn't support TLS");
   
   // If this global is linkonce/weak and the target handles this by emitting it
   // into a 'uniqued' section name, create and return the section now.
-  if (Kind.isWeak()) {
-    const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Kind);
-    // FIXME: Use mangler interface (PR4584).
-    std::string Name = Prefix+GV->getNameStr();
-    return getOrCreateSection(Name.c_str(), false, Kind.getKind());
+  if (Info.isWeak()) {
+    const char *Prefix = getCOFFSectionPrefixForUniqueGlobal(Info);
+    std::string Name = Mang->makeNameProper(GV->getNameStr());
+    return getOrCreateSection((Prefix+Name).c_str(), false, Info);
   }
   
-  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();
diff --git a/lib/Target/XCore/XCoreTargetObjectFile.cpp b/lib/Target/XCore/XCoreTargetObjectFile.cpp
index a9b46ed..0f2c6a3 100644
--- a/lib/Target/XCore/XCoreTargetObjectFile.cpp
+++ b/lib/Target/XCore/XCoreTargetObjectFile.cpp
@@ -16,9 +16,12 @@
 void XCoreTargetObjectFile::Initialize(MCContext &Ctx, const TargetMachine &TM){
   TargetLoweringObjectFileELF::Initialize(Ctx, TM);
 
-  TextSection = getOrCreateSection("\t.text", true, SectionKind::Text);
-  DataSection = getOrCreateSection("\t.dp.data", false, SectionKind::DataRel);
-  BSSSection_ = getOrCreateSection("\t.dp.bss", false, SectionKind::BSS);
+  TextSection = getOrCreateSection("\t.text", true, 
+                                   SectionKind::get(SectionKind::Text));
+  DataSection = getOrCreateSection("\t.dp.data", false, 
+                                   SectionKind::get(SectionKind::DataRel));
+  BSSSection_ = getOrCreateSection("\t.dp.bss", false, 
+                                   SectionKind::get(SectionKind::BSS));
   
   // TLS globals are lowered in the backend to arrays indexed by the current
   // thread id. After lowering they require no special handling by the linker
@@ -29,8 +32,8 @@
   if (TM.getSubtarget<XCoreSubtarget>().isXS1A())
     // FIXME: Why is this writable ("datarel")???
     ReadOnlySection = getOrCreateSection("\t.dp.rodata", false,
-                                         SectionKind::DataRel);
+                                        SectionKind::get(SectionKind::DataRel));
   else
     ReadOnlySection = getOrCreateSection("\t.cp.rodata", false,
-                                         SectionKind::ReadOnly);
+                                       SectionKind::get(SectionKind::ReadOnly));
 }