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

1 files changed, 187 insertions, 0 deletions

diff --git a/include/llvm/Target/TargetLoweringObjectFile.h b/include/llvm/Target/TargetLoweringObjectFile.h
new file mode 100644
index 0000000000..18ce1de01a
--- /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