TargetLoweringObjectFile.h revision 968ff1196768c0b6dbcc5508025a2923bfa73fab 
1//===-- llvm/Target/TargetLoweringObjectFile.h - Object Info ----*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements classes used to handle lowerings specific to common
11// object file formats.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H
16#define LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H
17
18#include "llvm/ADT/SmallVector.h"
19#include "llvm/ADT/StringMap.h"
20
21namespace llvm {
22  class MCSection;
23  class MCContext;
24  class GlobalValue;
25  class Mangler;
26  class TargetMachine;
27
28/// SectionKind - This is a simple POD value that classifies the properties of
29/// a section.  A global variable is classified into the deepest possible
30/// classification, and then the target maps them onto their sections based on
31/// what capabilities they have.
32///
33/// The comments below describe these as if they were an inheritance hierarchy
34/// in order to explain the predicates below.
35class SectionKind {
36public:
37  enum Kind {
38    /// Metadata - Debug info sections or other metadata.
39    Metadata,
40
41    /// Text - Text section, used for functions and other executable code.
42    Text,
43
44    /// ReadOnly - Data that is never written to at program runtime by the
45    /// program or the dynamic linker.  Things in the top-level readonly
46    /// SectionKind are not mergeable.
47    ReadOnly,
48
49        /// MergeableCString - This is a special section for nul-terminated
50        /// strings.  The linker can unique the C strings, knowing their
51        /// semantics.  Because it uniques based on the nul terminators, the
52        /// compiler can't put strings in this section that have embeded nuls
53        /// in them.
54        MergeableCString,
55
56        /// MergeableConst - These are sections for merging fixed-length
57        /// constants together.  For example, this can be used to unique
58        /// constant pool entries etc.
59        MergeableConst,
60
61            /// MergeableConst4 - This is a section used by 4-byte constants,
62            /// for example, floats.
63            MergeableConst4,
64
65            /// MergeableConst8 - This is a section used by 8-byte constants,
66            /// for example, doubles.
67            MergeableConst8,
68
69            /// MergeableConst16 - This is a section used by 16-byte constants,
70            /// for example, vectors.
71            MergeableConst16,
72
73    /// Writeable - This is the base of all segments that need to be written
74    /// to during program runtime.
75
76       /// ThreadLocal - This is the base of all TLS segments.  All TLS
77       /// objects must be writeable, otherwise there is no reason for them to
78       /// be thread local!
79
80           /// ThreadBSS - Zero-initialized TLS data objects.
81           ThreadBSS,
82
83           /// ThreadData - Initialized TLS data objects.
84           ThreadData,
85
86       /// GlobalWriteableData - Writeable data that is global (not thread
87       /// local).
88
89           /// BSS - Zero initialized writeable data.
90           BSS,
91
92           /// DataRel - This is the most general form of data that is written
93           /// to by the program, it can have random relocations to arbitrary
94           /// globals.
95           DataRel,
96
97               /// DataRelLocal - This is writeable data that has a non-zero
98               /// initializer and has relocations in it, but all of the
99               /// relocations are known to be within the final linked image
100               /// the global is linked into.
101               DataRelLocal,
102
103                   /// DataNoRel - This is writeable data that has a non-zero
104                   /// initializer, but whose initializer is known to have no
105                   /// relocations.
106                   DataNoRel,
107
108           /// ReadOnlyWithRel - These are global variables that are never
109           /// written to by the program, but that have relocations, so they
110           /// must be stuck in a writeable section so that the dynamic linker
111           /// can write to them.  If it chooses to, the dynamic linker can
112           /// mark the pages these globals end up on as read-only after it is
113           /// done with its relocation phase.
114           ReadOnlyWithRel,
115
116               /// ReadOnlyWithRelLocal - This is data that is readonly by the
117               /// program, but must be writeable so that the dynamic linker
118               /// can perform relocations in it.  This is used when we know
119               /// that all the relocations are to globals in this final
120               /// linked image.
121               ReadOnlyWithRelLocal
122
123  };
124
125protected:
126  Kind K : 6;
127
128public:
129
130  // FIXME: REMOVE.
131  Kind getKind() const { return K; }
132
133  bool isMetadata() const { return K == Metadata; }
134  bool isText() const { return K == Text; }
135
136  bool isReadOnly() const {
137    return K == ReadOnly || K == MergeableCString || isMergeableConst();
138  }
139
140  bool isMergeableCString() const { return K == MergeableCString; }
141  bool isMergeableConst() const {
142    return K == MergeableConst || K == MergeableConst4 ||
143           K == MergeableConst8 || K == MergeableConst16;
144  }
145
146  bool isMergeableConst4() const { return K == MergeableConst4; }
147  bool isMergeableConst8() const { return K == MergeableConst8; }
148  bool isMergeableConst16() const { return K == MergeableConst16; }
149
150  bool isWriteable() const {
151    return isThreadLocal() || isGlobalWriteableData();
152  }
153
154  bool isThreadLocal() const {
155    return K == ThreadData || K == ThreadBSS;
156  }
157
158  bool isThreadBSS() const { return K == ThreadBSS; }
159  bool isThreadData() const { return K == ThreadData; }
160
161  bool isGlobalWriteableData() const {
162    return isBSS() || isDataRel() || isReadOnlyWithRel();
163  }
164
165  bool isBSS() const { return K == BSS; }
166
167  bool isDataRel() const {
168    return K == DataRel || K == DataRelLocal || K == DataNoRel;
169  }
170
171  bool isDataRelLocal() const {
172    return K == DataRelLocal || K == DataNoRel;
173  }
174
175  bool isDataNoRel() const { return K == DataNoRel; }
176
177  bool isReadOnlyWithRel() const {
178    return K == ReadOnlyWithRel || K == ReadOnlyWithRelLocal;
179  }
180
181  bool isReadOnlyWithRelLocal() const {
182    return K == ReadOnlyWithRelLocal;
183  }
184
185  static SectionKind get(Kind K) {
186    SectionKind Res;
187    Res.K = K;
188    return Res;
189  }
190};
191
192
193/// SectionInfo - This class is a target-independent classification of a global
194/// which is used to simplify target-specific code by exposing common
195/// predicates.
196class SectionInfo : public SectionKind {
197  /// Weak - This is true if the referenced symbol is weak (i.e. linkonce,
198  /// weak, weak_odr, etc).  This is orthogonal from the categorization.
199  bool Weak : 1;
200
201public:
202
203  /// Weak - This is true if the referenced symbol is weak (i.e. linkonce,
204  /// weak, weak_odr, etc).  This is orthogonal from the categorization.
205  bool isWeak() const { return Weak; }
206
207  static SectionInfo get(Kind K, bool isWeak = false) {
208    SectionInfo Res;
209    Res.K = K;
210    Res.Weak = isWeak;
211    return Res;
212  }
213  static SectionInfo get(SectionKind K, bool isWeak = false) {
214    SectionInfo Res;
215    *(SectionKind*)&Res = K;
216    Res.Weak = isWeak;
217    return Res;
218  }
219};
220
221class TargetLoweringObjectFile {
222  MCContext *Ctx;
223protected:
224
225  TargetLoweringObjectFile();
226
227  /// TextSection - Section directive for standard text.
228  ///
229  const MCSection *TextSection;           // Defaults to ".text".
230
231  /// DataSection - Section directive for standard data.
232  ///
233  const MCSection *DataSection;           // Defaults to ".data".
234
235
236
237  // FIXME: SINK THESE.
238  const MCSection *BSSSection_;
239
240  /// ReadOnlySection - This is the directive that is emitted to switch to a
241  /// read-only section for constant data (e.g. data declared const,
242  /// jump tables).
243  const MCSection *ReadOnlySection;       // Defaults to NULL
244
245  /// TLSDataSection - Section directive for Thread Local data.
246  ///
247  const MCSection *TLSDataSection;        // Defaults to ".tdata".
248
249  /// TLSBSSSection - Section directive for Thread Local uninitialized data.
250  /// Null if this target doesn't support a BSS section.
251  ///
252  const MCSection *TLSBSSSection;         // Defaults to ".tbss".
253
254  const MCSection *CStringSection_;
255
256public:
257  // FIXME: NONPUB.
258  const MCSection *getOrCreateSection(const char *Name,
259                                      bool isDirective,
260                                      SectionKind K) const;
261public:
262
263  virtual ~TargetLoweringObjectFile();
264
265  /// Initialize - this method must be called before any actual lowering is
266  /// done.  This specifies the current context for codegen, and gives the
267  /// lowering implementations a chance to set up their default sections.
268  virtual void Initialize(MCContext &ctx, const TargetMachine &TM) {
269    Ctx = &ctx;
270  }
271
272
273  const MCSection *getTextSection() const { return TextSection; }
274  const MCSection *getDataSection() const { return DataSection; }
275
276  /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively
277  /// decide not to emit the UsedDirective for some symbols in llvm.used.
278  /// FIXME: REMOVE this (rdar://7071300)
279  virtual bool shouldEmitUsedDirectiveFor(const GlobalValue *GV,
280                                          Mangler *) const {
281    return (GV!=0);
282  }
283
284  /// getSectionForMergeableConstant - Given a mergeable constant with the
285  /// specified size and relocation information, return a section that it
286  /// should be placed in.
287  virtual const MCSection *
288  getSectionForMergeableConstant(SectionKind Kind) const;
289
290  /// getKindForNamedSection - If this target wants to be able to override
291  /// section flags based on the name of the section specified for a global
292  /// variable, it can implement this.  This is used on ELF systems so that
293  /// ".tbss" gets the TLS bit set etc.
294  virtual SectionKind getKindForNamedSection(const char *Section,
295                                             SectionKind K) const {
296    return K;
297  }
298
299  /// SectionForGlobal - This method computes the appropriate section to emit
300  /// the specified global variable or function definition.  This should not
301  /// be passed external (or available externally) globals.
302  const MCSection *SectionForGlobal(const GlobalValue *GV,
303                                    Mangler *Mang,
304                                    const TargetMachine &TM) const;
305
306  /// getSpecialCasedSectionGlobals - Allow the target to completely override
307  /// section assignment of a global.
308  /// FIXME: ELIMINATE this by making PIC16 implement ADDRESS with
309  /// getFlagsForNamedSection.
310  virtual const MCSection *
311  getSpecialCasedSectionGlobals(const GlobalValue *GV, Mangler *Mang,
312                                SectionInfo Kind) const {
313    return 0;
314  }
315
316  /// getSectionFlagsAsString - Turn the flags in the specified SectionKind
317  /// into a string that can be printed to the assembly file after the
318  /// ".section foo" part of a section directive.
319  virtual void getSectionFlagsAsString(SectionKind Kind,
320                                       SmallVectorImpl<char> &Str) const {
321  }
322
323protected:
324  virtual const MCSection *
325  SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
326                         Mangler *Mang, const TargetMachine &TM) const;
327};
328
329
330
331
332class TargetLoweringObjectFileELF : public TargetLoweringObjectFile {
333  bool AtIsCommentChar;  // True if @ is the comment character on this target.
334  bool HasCrazyBSS;
335public:
336  /// ELF Constructor - AtIsCommentChar is true if the CommentCharacter from TAI
337  /// is "@".
338  TargetLoweringObjectFileELF(bool atIsCommentChar = false,
339                              // FIXME: REMOVE AFTER UNIQUING IS FIXED.
340                              bool hasCrazyBSS = false)
341    : AtIsCommentChar(atIsCommentChar), HasCrazyBSS(hasCrazyBSS) {}
342
343  virtual void Initialize(MCContext &Ctx, const TargetMachine &TM);
344
345
346  /// getSectionForMergeableConstant - Given a mergeable constant with the
347  /// specified size and relocation information, return a section that it
348  /// should be placed in.
349  virtual const MCSection *
350  getSectionForMergeableConstant(SectionKind Kind) const;
351
352  virtual SectionKind getKindForNamedSection(const char *Section,
353                                             SectionKind K) const;
354  void getSectionFlagsAsString(SectionKind Kind,
355                               SmallVectorImpl<char> &Str) const;
356
357  virtual const MCSection *
358  SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
359                         Mangler *Mang, const TargetMachine &TM) const;
360protected:
361  const MCSection *DataRelSection;
362  const MCSection *DataRelLocalSection;
363  const MCSection *DataRelROSection;
364  const MCSection *DataRelROLocalSection;
365
366  const MCSection *MergeableConst4Section;
367  const MCSection *MergeableConst8Section;
368  const MCSection *MergeableConst16Section;
369};
370
371
372
373class TargetLoweringObjectFileMachO : public TargetLoweringObjectFile {
374  const MCSection *TextCoalSection;
375  const MCSection *ConstTextCoalSection;
376  const MCSection *ConstDataCoalSection;
377  const MCSection *ConstDataSection;
378  const MCSection *DataCoalSection;
379  const MCSection *FourByteConstantSection;
380  const MCSection *EightByteConstantSection;
381  const MCSection *SixteenByteConstantSection;
382public:
383
384  virtual void Initialize(MCContext &Ctx, const TargetMachine &TM);
385
386  virtual const MCSection *
387  SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
388                         Mangler *Mang, const TargetMachine &TM) const;
389
390  virtual const MCSection *
391  getSectionForMergeableConstant(SectionKind Kind) const;
392
393  /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively
394  /// decide not to emit the UsedDirective for some symbols in llvm.used.
395  /// FIXME: REMOVE this (rdar://7071300)
396  virtual bool shouldEmitUsedDirectiveFor(const GlobalValue *GV,
397                                          Mangler *) const;
398};
399
400
401
402class TargetLoweringObjectFileCOFF : public TargetLoweringObjectFile {
403public:
404  virtual void Initialize(MCContext &Ctx, const TargetMachine &TM);
405
406  virtual void getSectionFlagsAsString(SectionKind Kind,
407                                       SmallVectorImpl<char> &Str) const;
408
409  virtual const MCSection *
410  SelectSectionForGlobal(const GlobalValue *GV, SectionInfo Kind,
411                         Mangler *Mang, const TargetMachine &TM) const;
412};
413
414} // end namespace llvm
415
416#endif
417