← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/MC/MCSectionELF.h

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm/MC/MCSectionELF.h
1
 
//===- MCSectionELF.h - ELF Machine Code Sections ---------------*- 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 declares the MCSectionELF class.
11
 
//
12
 
//===----------------------------------------------------------------------===//
13
 
 
14
 
#ifndef LLVM_MC_MCSECTIONELF_H
15
 
#define LLVM_MC_MCSECTIONELF_H
16
 
 
17
 
#include "llvm/MC/MCSection.h"
18
 
 
19
 
namespace llvm {
20
 
  
21
 
/// MCSectionELF - This represents a section on linux, lots of unix variants
22
 
/// and some bare metal systems.
23
 
class MCSectionELF : public MCSection {
24
 
  /// SectionName - This is the name of the section.  The referenced memory is
25
 
  /// owned by TargetLoweringObjectFileELF's ELFUniqueMap.
26
 
  StringRef SectionName;
27
 
  
28
 
  /// Type - This is the sh_type field of a section, drawn from the enums below.
29
 
  unsigned Type;
30
 
  
31
 
  /// Flags - This is the sh_flags field of a section, drawn from the enums.
32
 
  /// below.
33
 
  unsigned Flags;
34
 
 
35
 
  /// IsExplicit - Indicates that this section comes from globals with an
36
 
  /// explicit section specified.
37
 
  bool IsExplicit;
38
 
 
39
 
  /// EntrySize - The size of each entry in this section. This size only
40
 
  /// makes sense for sections that contain fixed-sized entries. If a
41
 
  /// section does not contain fixed-sized entries 'EntrySize' will be 0.
42
 
  unsigned EntrySize;
43
 
  
44
 
private:
45
 
  friend class MCContext;
46
 
  MCSectionELF(StringRef Section, unsigned type, unsigned flags,
47
 
               SectionKind K, bool isExplicit, unsigned entrySize)
48
 
    : MCSection(SV_ELF, K), SectionName(Section), Type(type), Flags(flags),
49
 
      IsExplicit(isExplicit), EntrySize(entrySize) {}
50
 
  ~MCSectionELF();
51
 
public:
52
 
 
53
 
  /// ShouldOmitSectionDirective - Decides whether a '.section' directive
54
 
  /// should be printed before the section name
55
 
  bool ShouldOmitSectionDirective(StringRef Name, const MCAsmInfo &MAI) const;
56
 
 
57
 
  /// ShouldPrintSectionType - Only prints the section type if supported
58
 
  bool ShouldPrintSectionType(unsigned Ty) const;
59
 
 
60
 
  /// HasCommonSymbols - True if this section holds common symbols, this is
61
 
  /// indicated on the ELF object file by a symbol with SHN_COMMON section 
62
 
  /// header index.
63
 
  bool HasCommonSymbols() const;
64
 
  
65
 
  /// These are the section type and flags fields.  An ELF section can have
66
 
  /// only one Type, but can have more than one of the flags specified.
67
 
  ///
68
 
  /// Valid section types.
69
 
  enum {
70
 
    // This value marks the section header as inactive.
71
 
    SHT_NULL             = 0x00U,
72
 
 
73
 
    // Holds information defined by the program, with custom format and meaning.
74
 
    SHT_PROGBITS         = 0x01U,
75
 
 
76
 
    // This section holds a symbol table.
77
 
    SHT_SYMTAB           = 0x02U,
78
 
 
79
 
    // The section holds a string table.
80
 
    SHT_STRTAB           = 0x03U,
81
 
 
82
 
    // The section holds relocation entries with explicit addends.
83
 
    SHT_RELA             = 0x04U,
84
 
 
85
 
    // The section holds a symbol hash table.
86
 
    SHT_HASH             = 0x05U,
87
 
    
88
 
    // Information for dynamic linking.
89
 
    SHT_DYNAMIC          = 0x06U,
90
 
 
91
 
    // The section holds information that marks the file in some way.
92
 
    SHT_NOTE             = 0x07U,
93
 
 
94
 
    // A section of this type occupies no space in the file.
95
 
    SHT_NOBITS           = 0x08U,
96
 
 
97
 
    // The section holds relocation entries without explicit addends.
98
 
    SHT_REL              = 0x09U,
99
 
 
100
 
    // This section type is reserved but has unspecified semantics. 
101
 
    SHT_SHLIB            = 0x0AU,
102
 
 
103
 
    // This section holds a symbol table.
104
 
    SHT_DYNSYM           = 0x0BU,
105
 
 
106
 
    // This section contains an array of pointers to initialization functions.
107
 
    SHT_INIT_ARRAY       = 0x0EU,
108
 
 
109
 
    // This section contains an array of pointers to termination functions.
110
 
    SHT_FINI_ARRAY       = 0x0FU,
111
 
 
112
 
    // This section contains an array of pointers to functions that are invoked
113
 
    // before all other initialization functions.
114
 
    SHT_PREINIT_ARRAY    = 0x10U,
115
 
 
116
 
    // A section group is a set of sections that are related and that must be
117
 
    // treated specially by the linker.
118
 
    SHT_GROUP            = 0x11U,
119
 
 
120
 
    // This section is associated with a section of type SHT_SYMTAB, when the
121
 
    // referenced symbol table contain the escape value SHN_XINDEX
122
 
    SHT_SYMTAB_SHNDX     = 0x12U,
123
 
 
124
 
    LAST_KNOWN_SECTION_TYPE = SHT_SYMTAB_SHNDX
125
 
  }; 
126
 
 
127
 
  /// Valid section flags.
128
 
  enum {
129
 
    // The section contains data that should be writable.
130
 
    SHF_WRITE            = 0x1U,
131
 
 
132
 
    // The section occupies memory during execution.
133
 
    SHF_ALLOC            = 0x2U,
134
 
 
135
 
    // The section contains executable machine instructions.
136
 
    SHF_EXECINSTR        = 0x4U,
137
 
 
138
 
    // The data in the section may be merged to eliminate duplication.
139
 
    SHF_MERGE            = 0x10U,
140
 
 
141
 
    // Elements in the section consist of null-terminated character strings.
142
 
    SHF_STRINGS          = 0x20U,
143
 
 
144
 
    // A field in this section holds a section header table index.
145
 
    SHF_INFO_LINK        = 0x40U,
146
 
 
147
 
    // Adds special ordering requirements for link editors.
148
 
    SHF_LINK_ORDER       = 0x80U,
149
 
 
150
 
    // This section requires special OS-specific processing to avoid incorrect
151
 
    // behavior.
152
 
    SHF_OS_NONCONFORMING = 0x100U,
153
 
 
154
 
    // This section is a member of a section group.
155
 
    SHF_GROUP            = 0x200U,
156
 
 
157
 
    // This section holds Thread-Local Storage.
158
 
    SHF_TLS              = 0x400U,
159
 
 
160
 
    
161
 
    // Start of target-specific flags.
162
 
 
163
 
    /// XCORE_SHF_CP_SECTION - All sections with the "c" flag are grouped
164
 
    /// together by the linker to form the constant pool and the cp register is
165
 
    /// set to the start of the constant pool by the boot code.
166
 
    XCORE_SHF_CP_SECTION = 0x800U,
167
 
    
168
 
    /// XCORE_SHF_DP_SECTION - All sections with the "d" flag are grouped
169
 
    /// together by the linker to form the data section and the dp register is
170
 
    /// set to the start of the section by the boot code.
171
 
    XCORE_SHF_DP_SECTION = 0x1000U
172
 
  };
173
 
 
174
 
  StringRef getSectionName() const { return SectionName; }
175
 
  unsigned getType() const { return Type; }
176
 
  unsigned getFlags() const { return Flags; }
177
 
  unsigned getEntrySize() const { return EntrySize; }
178
 
  
179
 
  void PrintSwitchToSection(const MCAsmInfo &MAI,
180
 
                            raw_ostream &OS) const;
181
 
  
182
 
  /// isBaseAddressKnownZero - We know that non-allocatable sections (like
183
 
  /// debug info) have a base of zero.
184
 
  virtual bool isBaseAddressKnownZero() const {
185
 
    return (getFlags() & SHF_ALLOC) == 0;
186
 
  }
187
 
 
188
 
  static bool classof(const MCSection *S) {
189
 
    return S->getVariant() == SV_ELF;
190
 
  }
191
 
  static bool classof(const MCSectionELF *) { return true; }
192
 
};
193
 
 
194
 
} // end namespace llvm
195
 
 
196
 
#endif