Rip all of the global variable lowering logic out of TargetAsmInfo. Since

it is highly specific to the object file that will be generated in the end,
this introduces a new TargetLoweringObjectFile interface that is implemented
for each of ELF/MachO/COFF/Alpha/PIC16 and XCore.

Though still is still a brutal and ugly refactoring, this is a major step
towards goodness.

This patch also:
1. fixes a bunch of dangling pointer problems in the PIC16 backend.
2. disables the TargetLowering copy ctor which PIC16 was accidentally using.
3. gets us closer to xcore having its own crazy target section flags and
   pic16 not having to shadow sections with its own objects.
4. fixes wierdness where ELF targets would set CStringSection but not
   CStringSection_.  Factor the code better.
5. fixes some bugs in string lowering on ELF targets.




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

7 files changed, 203 insertions, 147 deletions

diff --git a/include/llvm/CodeGen/AsmPrinter.h b/include/llvm/CodeGen/AsmPrinter.h
index 78de33f..6cd2d8e 100644
--- a/include/llvm/CodeGen/AsmPrinter.h
+++ b/include/llvm/CodeGen/AsmPrinter.h
@@ -39,6 +39,7 @@ namespace llvm {
   class Mangler;
   class Section;
   class TargetAsmInfo;
+  class TargetLoweringObjectFile;
   class Type;
   class formatted_raw_ostream;
 
@@ -75,6 +76,9 @@ namespace llvm {
     ///
     TargetMachine &TM;
     
+    /// getObjFileLowering - Return information about object file lowering.
+    const TargetLoweringObjectFile &getObjFileLowering() const;
+    
     /// Target Asm Printer information.
     ///
     const TargetAsmInfo *TAI;
diff --git a/include/llvm/Target/COFFTargetAsmInfo.h b/include/llvm/Target/COFFTargetAsmInfo.h
index 4a60c0c..a035f2b 100644
--- a/include/llvm/Target/COFFTargetAsmInfo.h
+++ b/include/llvm/Target/COFFTargetAsmInfo.h
@@ -16,15 +16,9 @@ namespace llvm {
   class COFFTargetAsmInfo : public TargetAsmInfo {
   protected:
     explicit COFFTargetAsmInfo(const TargetMachine &TM);
-  public:
-    virtual void getSectionFlagsAsString(SectionKind Kind,
-                                         SmallVectorImpl<char> &Str) const;
-    
-    virtual const Section *
-    SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind) const;
       
   };
 }
 
 
-#endif // LLVM_ELF_TARGET_ASM_INFO_H
+#endif // LLVM_COFF_TARGET_ASM_INFO_H
diff --git a/include/llvm/Target/DarwinTargetAsmInfo.h b/include/llvm/Target/DarwinTargetAsmInfo.h
index 69bc551..c934c05 100644
--- a/include/llvm/Target/DarwinTargetAsmInfo.h
+++ b/include/llvm/Target/DarwinTargetAsmInfo.h
@@ -24,27 +24,9 @@ namespace llvm {
   class Mangler;
 
   struct DarwinTargetAsmInfo : public TargetAsmInfo {
-    const Section* TextCoalSection;
-    const Section* ConstTextCoalSection;
-    const Section* ConstDataCoalSection;
-    const Section* ConstDataSection;
-    const Section* DataCoalSection;
-    const Section* FourByteConstantSection;
-    const Section* EightByteConstantSection;
-    const Section* SixteenByteConstantSection;
-
     explicit DarwinTargetAsmInfo(const TargetMachine &TM);
-    virtual const Section* SelectSectionForGlobal(const GlobalValue *GV,
-                                                  SectionKind Kind) const;
     virtual bool emitUsedDirectiveFor(const GlobalValue *GV,
                                       Mangler *Mang) const;
-
-    
-    virtual const Section *
-    getSectionForMergeableConstant(SectionKind Kind) const;
-    
-  private:
-    const Section* MergeableStringSection(const GlobalVariable *GV) const;
   };
 }
 
diff --git a/include/llvm/Target/ELFTargetAsmInfo.h b/include/llvm/Target/ELFTargetAsmInfo.h
index 1b5bc54..1b141d5 100644
--- a/include/llvm/Target/ELFTargetAsmInfo.h
+++ b/include/llvm/Target/ELFTargetAsmInfo.h
@@ -21,29 +21,6 @@ namespace llvm {
 
   struct ELFTargetAsmInfo : public TargetAsmInfo {
     ELFTargetAsmInfo(const TargetMachine &TM);
-
-    /// getSectionForMergeableConstant - Given a mergeable constant with the
-    /// specified size and relocation information, return a section that it
-    /// should be placed in.
-    virtual const Section *
-    getSectionForMergeableConstant(SectionKind Kind) const;
-    
-    virtual SectionKind::Kind getKindForNamedSection(const char *Section,
-                                                     SectionKind::Kind K) const;
-    void getSectionFlagsAsString(SectionKind Kind,
-                                 SmallVectorImpl<char> &Str) const;
-    
-    virtual const Section* SelectSectionForGlobal(const GlobalValue *GV,
-                                                  SectionKind Kind) const;
-    
-    const Section *DataRelSection;
-    const Section *DataRelLocalSection;
-    const Section *DataRelROSection;
-    const Section *DataRelROLocalSection;
-
-    const Section *MergeableConst4Section;
-    const Section *MergeableConst8Section;
-    const Section *MergeableConst16Section;
   };
 }
 
diff --git a/include/llvm/Target/TargetAsmInfo.h b/include/llvm/Target/TargetAsmInfo.h
index 9031dd2..95a6d53 100644
--- a/include/llvm/Target/TargetAsmInfo.h
+++ b/include/llvm/Target/TargetAsmInfo.h
@@ -214,15 +214,12 @@ namespace llvm {
   };
 
   class Section {
-    friend class TargetAsmInfo;
-    friend class StringMapEntry<Section>;
-    friend class StringMap<Section>;
+  public:
 
     std::string Name;
     SectionKind Kind;
-    explicit Section() { }
 
-  public:
+    explicit Section() { }
     const std::string &getName() const { return Name; }
     SectionKind getKind() const { return Kind; }
   };
@@ -230,8 +227,6 @@ namespace llvm {
   /// TargetAsmInfo - This class is intended to be used as a base class for asm
   /// properties and features specific to the target.
   class TargetAsmInfo {
-  private:
-    mutable StringMap<Section> Sections;
   protected:
     /// TM - The current TargetMachine.
     const TargetMachine &TM;
@@ -240,33 +235,11 @@ namespace llvm {
     // Properties to be set by the target writer, used to configure asm printer.
     //
 
-    /// TextSection - Section directive for standard text.
-    ///
-    const Section *TextSection;           // Defaults to ".text".
-
-    /// DataSection - Section directive for standard data.
-    ///
-    const Section *DataSection;           // Defaults to ".data".
-
     /// BSSSection - Section directive for uninitialized data.  Null if this
     /// target doesn't support a BSS section.
     ///
+/// FIXME: REMOVE.
     const char *BSSSection;               // Default to ".bss".
-    const Section *BSSSection_;
-
-    /// ReadOnlySection - This is the directive that is emitted to switch to a
-    /// read-only section for constant data (e.g. data declared const,
-    /// jump tables).
-    const Section *ReadOnlySection;       // Defaults to NULL
-
-    /// TLSDataSection - Section directive for Thread Local data.
-    ///
-    const Section *TLSDataSection;        // Defaults to ".tdata".
-
-    /// TLSBSSSection - Section directive for Thread Local uninitialized data.
-    /// Null if this target doesn't support a BSS section.
-    ///
-    const Section *TLSBSSSection;         // Defaults to ".tbss".
 
     /// ZeroFillDirective - Directive for emitting a global to the ZeroFill
     /// section on this target.  Null if this target doesn't support zerofill.
@@ -456,8 +429,8 @@ namespace llvm {
     /// cstring constants (null terminated string that does not contain any
     /// other null bytes) on this target. This is commonly supported as
     /// ".cstring".
+/// FIXME: REMOVE.
     const char *CStringSection;           // Defaults to NULL
-    const Section *CStringSection_;
 
     /// StaticCtorsSection - This is the directive that is emitted to switch to
     /// a section to emit the static constructor list.
@@ -642,10 +615,6 @@ namespace llvm {
     explicit TargetAsmInfo(const TargetMachine &TM);
     virtual ~TargetAsmInfo();
 
-    const Section *getOrCreateSection(const char *Name,
-                                      bool isDirective,
-                                      SectionKind::Kind K) const;
-
     /// Measure the specified inline asm to determine an approximation of its
     /// length.
     virtual unsigned getInlineAsmLength(const char *Str) const;
@@ -665,48 +634,6 @@ namespace llvm {
     virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason,
                                            bool Global) const;
 
-    
-    /// getSectionForMergeableConstant - Given a Mergeable constant with the
-    /// specified size and relocation information, return a section that it
-    /// should be placed in.
-    virtual const Section *getSectionForMergeableConstant(SectionKind Kind)const;
-
-    
-    /// getKindForNamedSection - If this target wants to be able to override
-    /// 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{
-      return K;
-    }
-    
-    /// SectionForGlobal - This method computes the appropriate section to emit
-    /// the specified global variable or function definition.  This should not
-    /// be passed external (or available externally) globals.
-    // FIXME: MOVE TO ASMPRINTER.
-    const Section* SectionForGlobal(const GlobalValue *GV) const;
-    
-    /// getSpecialCasedSectionGlobals - Allow the target to completely override
-    /// section assignment of a global.
-    /// FIXME: ELIMINATE this by making PIC16 implement ADDRESS with
-    /// getFlagsForNamedSection.
-    virtual const Section *
-    getSpecialCasedSectionGlobals(const GlobalValue *GV,
-                                  SectionKind Kind) const {
-      return 0;
-    }
-    
-    /// getSectionFlagsAsString - Turn the flags in the specified SectionKind
-    /// into a string that can be printed to the assembly file after the
-    /// ".section foo" part of a section directive.
-    virtual void getSectionFlagsAsString(SectionKind Kind,
-                                         SmallVectorImpl<char> &Str) const {
-    }
-
-// FIXME: Eliminate this.
-    virtual const Section* SelectSectionForGlobal(const GlobalValue *GV,
-                                                  SectionKind Kind) const;
 
     /// getSLEB128Size - Compute the number of bytes required for a signed
     /// leb128 value.
@@ -734,27 +661,9 @@ namespace llvm {
 
     // Accessors.
     //
-    const Section *getTextSection() const {
-      return TextSection;
-    }
-    const Section *getDataSection() const {
-      return DataSection;
-    }
     const char *getBSSSection() const {
       return BSSSection;
     }
-    const Section *getBSSSection_() const {
-      return BSSSection_;
-    }
-    const Section *getReadOnlySection() const {
-      return ReadOnlySection;
-    }
-    const Section *getTLSDataSection() const {
-      return TLSDataSection;
-    }
-    const Section *getTLSBSSSection() const {
-      return TLSBSSSection;
-    }
     const char *getZeroFillDirective() const {
       return ZeroFillDirective;
     }
@@ -869,9 +778,6 @@ namespace llvm {
     const char *getCStringSection() const {
       return CStringSection;
     }
-    const Section *getCStringSection_() const {
-      return CStringSection_;
-    }
     const char *getStaticCtorsSection() const {
       return StaticCtorsSection;
     }
diff --git a/include/llvm/Target/TargetLowering.h b/include/llvm/Target/TargetLowering.h
index 6c216c9..1dec92b 100644
--- a/include/llvm/Target/TargetLowering.h
+++ b/include/llvm/Target/TargetLowering.h
@@ -54,6 +54,7 @@ namespace llvm {
   class TargetMachine;
   class TargetRegisterClass;
   class TargetSubtarget;
+  class TargetLoweringObjectFile;
   class Value;
 
   // FIXME: should this be here?
@@ -77,6 +78,8 @@ namespace llvm {
 /// target-specific constructs to SelectionDAG operators.
 ///
 class TargetLowering {
+  TargetLowering(const TargetLowering&);  // DO NOT IMPLEMENT
+  void operator=(const TargetLowering&);  // DO NOT IMPLEMENT
 public:
   /// LegalizeAction - This enum indicates whether operations are valid for a
   /// target, and if not, what action should be used to make them valid.
@@ -98,11 +101,13 @@ public:
     SchedulingForRegPressure       // Scheduling for lowest register pressure.
   };
 
-  explicit TargetLowering(TargetMachine &TM);
+  /// NOTE: The constructor takes ownership of TLOF.
+  explicit TargetLowering(TargetMachine &TM, TargetLoweringObjectFile *TLOF);
   virtual ~TargetLowering();
 
   TargetMachine &getTargetMachine() const { return TM; }
   const TargetData *getTargetData() const { return TD; }
+  const TargetLoweringObjectFile &getObjFileLowering() const { return TLOF; }
 
   bool isBigEndian() const { return !IsLittleEndian; }
   bool isLittleEndian() const { return IsLittleEndian; }
@@ -1475,6 +1480,7 @@ public:
 private:
   TargetMachine &TM;
   const TargetData *TD;
+  TargetLoweringObjectFile &TLOF;
 
   /// PointerTy - The type to use for pointers, usually i32 or i64.
   ///
diff --git a/include/llvm/Target/TargetLoweringObjectFile.h b/include/llvm/Target/TargetLoweringObjectFile.h
new file mode 100644
index 0000000..18ce1de
--- /dev/null
+++ b/include/llvm/Target/TargetLoweringObjectFile.h
@@ -0,0 +1,187 @@
+//===-- llvm/Target/TargetLoweringObjectFile.h - Object Info ----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements classes used to handle lowerings specific to common
+// object file formats.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H
+#define LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H
+
+// FIXME: Switch to MC.
+#include "llvm/Target/TargetAsmInfo.h"
+
+namespace llvm {
+  
+class TargetLoweringObjectFile {
+private:
+  mutable StringMap<Section> Sections;
+protected:
+  
+  TargetLoweringObjectFile();
+  
+  /// TextSection - Section directive for standard text.
+  ///
+  const Section *TextSection;           // Defaults to ".text".
+  
+  /// DataSection - Section directive for standard data.
+  ///
+  const Section *DataSection;           // Defaults to ".data".
+  
+  
+  
+  // FIXME: SINK THESE.
+  const Section *BSSSection_;
+
+  /// ReadOnlySection - This is the directive that is emitted to switch to a
+  /// read-only section for constant data (e.g. data declared const,
+  /// jump tables).
+  const Section *ReadOnlySection;       // Defaults to NULL
+  
+  /// TLSDataSection - Section directive for Thread Local data.
+  ///
+  const Section *TLSDataSection;        // Defaults to ".tdata".
+  
+  /// TLSBSSSection - Section directive for Thread Local uninitialized data.
+  /// Null if this target doesn't support a BSS section.
+  ///
+  const Section *TLSBSSSection;         // Defaults to ".tbss".
+  
+  const Section *CStringSection_;
+  
+public:
+  // FIXME: NONPUB.
+  const Section *getOrCreateSection(const char *Name,
+                                    bool isDirective,
+                                    SectionKind::Kind K) const;
+public:
+  
+  virtual ~TargetLoweringObjectFile();
+  
+  const Section *getTextSection() const { return TextSection; }
+  const Section *getDataSection() const { return DataSection; }
+  
+  
+  /// getSectionForMergeableConstant - Given a mergeable constant with the
+  /// specified size and relocation information, return a section that it
+  /// should be placed in.
+  virtual const Section *
+  getSectionForMergeableConstant(SectionKind Kind) const;
+  
+  /// getKindForNamedSection - If this target wants to be able to override
+  /// 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{
+    return K;
+  }
+  
+  /// SectionForGlobal - This method computes the appropriate section to emit
+  /// the specified global variable or function definition.  This should not
+  /// be passed external (or available externally) globals.
+  const Section *SectionForGlobal(const GlobalValue *GV,
+                                  const TargetMachine &TM) const;
+  
+  /// getSpecialCasedSectionGlobals - Allow the target to completely override
+  /// section assignment of a global.
+  /// FIXME: ELIMINATE this by making PIC16 implement ADDRESS with
+  /// getFlagsForNamedSection.
+  virtual const Section *
+  getSpecialCasedSectionGlobals(const GlobalValue *GV,
+                                SectionKind Kind) const {
+    return 0;
+  }
+  
+  /// getSectionFlagsAsString - Turn the flags in the specified SectionKind
+  /// into a string that can be printed to the assembly file after the
+  /// ".section foo" part of a section directive.
+  virtual void getSectionFlagsAsString(SectionKind Kind,
+                                       SmallVectorImpl<char> &Str) const {
+  }
+  
+protected:
+  virtual const Section *SelectSectionForGlobal(const GlobalValue *GV,
+                                                SectionKind Kind,
+                                                const TargetMachine &TM) const;
+};
+  
+  
+  
+
+class TargetLoweringObjectFileELF : public TargetLoweringObjectFile {
+  bool AtIsCommentChar;  // True if @ is the comment character on this target.
+public:
+  /// ELF Constructor - AtIsCommentChar is true if the CommentCharacter from TAI
+  /// is "@".
+  TargetLoweringObjectFileELF(bool AtIsCommentChar = false,
+                              // FIXME: REMOVE AFTER UNIQUING IS FIXED.
+                              bool HasCrazyBSS = false);
+  
+  /// getSectionForMergeableConstant - Given a mergeable constant with the
+  /// specified size and relocation information, return a section that it
+  /// should be placed in.
+  virtual const Section *
+  getSectionForMergeableConstant(SectionKind Kind) const;
+  
+  virtual SectionKind::Kind getKindForNamedSection(const char *Section,
+                                                   SectionKind::Kind K) const;
+  void getSectionFlagsAsString(SectionKind Kind,
+                               SmallVectorImpl<char> &Str) const;
+  
+  virtual const Section* SelectSectionForGlobal(const GlobalValue *GV,
+                                                SectionKind Kind,
+                                                const TargetMachine &TM) const;
+protected:
+  const Section *DataRelSection;
+  const Section *DataRelLocalSection;
+  const Section *DataRelROSection;
+  const Section *DataRelROLocalSection;
+  
+  const Section *MergeableConst4Section;
+  const Section *MergeableConst8Section;
+  const Section *MergeableConst16Section;
+};
+
+class TargetLoweringObjectFileMachO : public TargetLoweringObjectFile {
+  const Section *TextCoalSection;
+  const Section *ConstTextCoalSection;
+  const Section *ConstDataCoalSection;
+  const Section *ConstDataSection;
+  const Section *DataCoalSection;
+  const Section *FourByteConstantSection;
+  const Section *EightByteConstantSection;
+  const Section *SixteenByteConstantSection;
+public:
+  TargetLoweringObjectFileMachO();
+  virtual const Section *SelectSectionForGlobal(const GlobalValue *GV,
+                                                SectionKind Kind,
+                                                const TargetMachine &TM) const;
+  
+  virtual const Section *
+  getSectionForMergeableConstant(SectionKind Kind) const;
+};
+
+
+
+class TargetLoweringObjectFileCOFF : public TargetLoweringObjectFile {
+public:
+  TargetLoweringObjectFileCOFF();
+  virtual void getSectionFlagsAsString(SectionKind Kind,
+                                       SmallVectorImpl<char> &Str) const;
+  
+  virtual const Section *
+  SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
+                         const TargetMachine &TM) const;
+};
+
+} // end namespace llvm
+
+#endif