MCSectionELF.h revision 3e09669bc44aeb053e58ae8245ad0e49570b0e21
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) 48 : MCSection(SV_ELF, K), SectionName(Section), Type(type), Flags(flags), 49 IsExplicit(isExplicit) {} 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 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 178 void PrintSwitchToSection(const MCAsmInfo &MAI, 179 raw_ostream &OS) const; 180 181 /// isBaseAddressKnownZero - We know that non-allocatable sections (like 182 /// debug info) have a base of zero. 183 virtual bool isBaseAddressKnownZero() const { 184 return (getFlags() & SHF_ALLOC) == 0; 185 } 186 187 static bool classof(const MCSection *S) { 188 return S->getVariant() == SV_ELF; 189 } 190 static bool classof(const MCSectionELF *) { return true; } 191}; 192 193} // end namespace llvm 194 195#endif 196