MCSectionELF.h revision 037b5be15a421b99066bb284027750a16ddd0fae
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 19namespace llvm { 20 21/// MCSectionELF - This represents a section on linux, lots of unix variants 22/// and some bare metal systems. 23class 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 44private: 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(); 51public: 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 // Start of target-specific flags. 125 126 // Exception Index table 127 SHT_ARM_EXIDX = 0x70000001U, 128 // BPABI DLL dynamic linking pre-emption map 129 SHT_ARM_PREEMPTMAP = 0x70000002U, 130 // Object file compatibility attributes 131 SHT_ARM_ATTRIBUTES = 0x70000003U, 132 SHT_ARM_DEBUGOVERLAY = 0x70000004U, 133 SHT_ARM_OVERLAYSECTION = 0x70000005U, 134 135 LAST_KNOWN_SECTION_TYPE = SHT_ARM_OVERLAYSECTION 136 }; 137 138 /// Valid section flags. 139 enum { 140 // The section contains data that should be writable. 141 SHF_WRITE = 0x1U, 142 143 // The section occupies memory during execution. 144 SHF_ALLOC = 0x2U, 145 146 // The section contains executable machine instructions. 147 SHF_EXECINSTR = 0x4U, 148 149 // The data in the section may be merged to eliminate duplication. 150 SHF_MERGE = 0x10U, 151 152 // Elements in the section consist of null-terminated character strings. 153 SHF_STRINGS = 0x20U, 154 155 // A field in this section holds a section header table index. 156 SHF_INFO_LINK = 0x40U, 157 158 // Adds special ordering requirements for link editors. 159 SHF_LINK_ORDER = 0x80U, 160 161 // This section requires special OS-specific processing to avoid incorrect 162 // behavior. 163 SHF_OS_NONCONFORMING = 0x100U, 164 165 // This section is a member of a section group. 166 SHF_GROUP = 0x200U, 167 168 // This section holds Thread-Local Storage. 169 SHF_TLS = 0x400U, 170 171 172 // Start of target-specific flags. 173 174 /// XCORE_SHF_CP_SECTION - All sections with the "c" flag are grouped 175 /// together by the linker to form the constant pool and the cp register is 176 /// set to the start of the constant pool by the boot code. 177 XCORE_SHF_CP_SECTION = 0x800U, 178 179 /// XCORE_SHF_DP_SECTION - All sections with the "d" flag are grouped 180 /// together by the linker to form the data section and the dp register is 181 /// set to the start of the section by the boot code. 182 XCORE_SHF_DP_SECTION = 0x1000U 183 }; 184 185 StringRef getSectionName() const { return SectionName; } 186 unsigned getType() const { return Type; } 187 unsigned getFlags() const { return Flags; } 188 unsigned getEntrySize() const { return EntrySize; } 189 190 void PrintSwitchToSection(const MCAsmInfo &MAI, 191 raw_ostream &OS) const; 192 virtual bool UseCodeAlign() const; 193 194 /// isBaseAddressKnownZero - We know that non-allocatable sections (like 195 /// debug info) have a base of zero. 196 virtual bool isBaseAddressKnownZero() const { 197 return (getFlags() & SHF_ALLOC) == 0; 198 } 199 200 static bool classof(const MCSection *S) { 201 return S->getVariant() == SV_ELF; 202 } 203 static bool classof(const MCSectionELF *) { return true; } 204 205 // Return the entry size for sections with fixed-width data. 206 static unsigned DetermineEntrySize(SectionKind Kind); 207 208}; 209 210} // end namespace llvm 211 212#endif 213