MCSectionMachO.cpp revision fe40f9551cab75c4576ee03e6a994fe4fb4530d9
1//===- lib/MC/MCSectionMachO.cpp - MachO Code Section Representation ------===// 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#include "llvm/MC/MCSectionMachO.h" 11#include "llvm/MC/MCContext.h" 12#include "llvm/Support/raw_ostream.h" 13using namespace llvm; 14 15/// SectionTypeDescriptors - These are strings that describe the various section 16/// types. This *must* be kept in order with and stay synchronized with the 17/// section type list. 18static const struct { 19 const char *AssemblerName, *EnumName; 20} SectionTypeDescriptors[MCSectionMachO::LAST_KNOWN_SECTION_TYPE+1] = { 21 { "regular", "S_REGULAR" }, // 0x00 22 { 0, "S_ZEROFILL" }, // 0x01 23 { "cstring_literals", "S_CSTRING_LITERALS" }, // 0x02 24 { "4byte_literals", "S_4BYTE_LITERALS" }, // 0x03 25 { "8byte_literals", "S_8BYTE_LITERALS" }, // 0x04 26 { "literal_pointers", "S_LITERAL_POINTERS" }, // 0x05 27 { "non_lazy_symbol_pointers", "S_NON_LAZY_SYMBOL_POINTERS" }, // 0x06 28 { "lazy_symbol_pointers", "S_LAZY_SYMBOL_POINTERS" }, // 0x07 29 { "symbol_stubs", "S_SYMBOL_STUBS" }, // 0x08 30 { "mod_init_funcs", "S_MOD_INIT_FUNC_POINTERS" }, // 0x09 31 { "mod_term_funcs", "S_MOD_TERM_FUNC_POINTERS" }, // 0x0A 32 { "coalesced", "S_COALESCED" }, // 0x0B 33 { 0, /*FIXME??*/ "S_GB_ZEROFILL" }, // 0x0C 34 { "interposing", "S_INTERPOSING" }, // 0x0D 35 { "16byte_literals", "S_16BYTE_LITERALS" }, // 0x0E 36 { 0, /*FIXME??*/ "S_DTRACE_DOF" }, // 0x0F 37 { 0, /*FIXME??*/ "S_LAZY_DYLIB_SYMBOL_POINTERS" }, // 0x10 38 { "thread_local_regular", "S_THREAD_LOCAL_REGULAR" }, // 0x11 39 { "thread_local_zerofill", "S_THREAD_LOCAL_ZEROFILL" }, // 0x12 40 { "thread_local_variables", "S_THREAD_LOCAL_VARIABLES" }, // 0x13 41 { "thread_local_variable_pointers", 42 "S_THREAD_LOCAL_VARIABLE_POINTERS" }, // 0x14 43 { "thread_local_init_function_pointers", 44 "S_THREAD_LOCAL_INIT_FUNCTION_POINTERS"}, // 0x15 45}; 46 47 48/// SectionAttrDescriptors - This is an array of descriptors for section 49/// attributes. Unlike the SectionTypeDescriptors, this is not directly indexed 50/// by attribute, instead it is searched. The last entry has an AttrFlagEnd 51/// AttrFlag value. 52static const struct { 53 unsigned AttrFlag; 54 const char *AssemblerName, *EnumName; 55} SectionAttrDescriptors[] = { 56#define ENTRY(ASMNAME, ENUM) \ 57 { MCSectionMachO::ENUM, ASMNAME, #ENUM }, 58ENTRY("pure_instructions", S_ATTR_PURE_INSTRUCTIONS) 59ENTRY("no_toc", S_ATTR_NO_TOC) 60ENTRY("strip_static_syms", S_ATTR_STRIP_STATIC_SYMS) 61ENTRY("no_dead_strip", S_ATTR_NO_DEAD_STRIP) 62ENTRY("live_support", S_ATTR_LIVE_SUPPORT) 63ENTRY("self_modifying_code", S_ATTR_SELF_MODIFYING_CODE) 64ENTRY("debug", S_ATTR_DEBUG) 65ENTRY(0 /*FIXME*/, S_ATTR_SOME_INSTRUCTIONS) 66ENTRY(0 /*FIXME*/, S_ATTR_EXT_RELOC) 67ENTRY(0 /*FIXME*/, S_ATTR_LOC_RELOC) 68#undef ENTRY 69 { 0, "none", 0 }, // used if section has no attributes but has a stub size 70#define AttrFlagEnd 0xffffffff // non legal value, multiple attribute bits set 71 { AttrFlagEnd, 0, 0 } 72}; 73 74MCSectionMachO::MCSectionMachO(StringRef Segment, StringRef Section, 75 unsigned TAA, unsigned reserved2, SectionKind K) 76 : MCSection(SV_MachO, K), TypeAndAttributes(TAA), Reserved2(reserved2) { 77 assert(Segment.size() <= 16 && Section.size() <= 16 && 78 "Segment or section string too long"); 79 for (unsigned i = 0; i != 16; ++i) { 80 if (i < Segment.size()) 81 SegmentName[i] = Segment[i]; 82 else 83 SegmentName[i] = 0; 84 85 if (i < Section.size()) 86 SectionName[i] = Section[i]; 87 else 88 SectionName[i] = 0; 89 } 90} 91 92void MCSectionMachO::PrintSwitchToSection(const MCAsmInfo &MAI, 93 raw_ostream &OS) const { 94 OS << "\t.section\t" << getSegmentName() << ',' << getSectionName(); 95 96 // Get the section type and attributes. 97 unsigned TAA = getTypeAndAttributes(); 98 if (TAA == 0) { 99 OS << '\n'; 100 return; 101 } 102 103 OS << ','; 104 105 unsigned SectionType = TAA & MCSectionMachO::SECTION_TYPE; 106 assert(SectionType <= MCSectionMachO::LAST_KNOWN_SECTION_TYPE && 107 "Invalid SectionType specified!"); 108 109 if (SectionTypeDescriptors[SectionType].AssemblerName) 110 OS << SectionTypeDescriptors[SectionType].AssemblerName; 111 else 112 OS << "<<" << SectionTypeDescriptors[SectionType].EnumName << ">>"; 113 114 // If we don't have any attributes, we're done. 115 unsigned SectionAttrs = TAA & MCSectionMachO::SECTION_ATTRIBUTES; 116 if (SectionAttrs == 0) { 117 // If we have a S_SYMBOL_STUBS size specified, print it along with 'none' as 118 // the attribute specifier. 119 if (Reserved2 != 0) 120 OS << ",none," << Reserved2; 121 OS << '\n'; 122 return; 123 } 124 125 // Check each attribute to see if we have it. 126 char Separator = ','; 127 for (unsigned i = 0; SectionAttrDescriptors[i].AttrFlag; ++i) { 128 // Check to see if we have this attribute. 129 if ((SectionAttrDescriptors[i].AttrFlag & SectionAttrs) == 0) 130 continue; 131 132 // Yep, clear it and print it. 133 SectionAttrs &= ~SectionAttrDescriptors[i].AttrFlag; 134 135 OS << Separator; 136 if (SectionAttrDescriptors[i].AssemblerName) 137 OS << SectionAttrDescriptors[i].AssemblerName; 138 else 139 OS << "<<" << SectionAttrDescriptors[i].EnumName << ">>"; 140 Separator = '+'; 141 } 142 143 assert(SectionAttrs == 0 && "Unknown section attributes!"); 144 145 // If we have a S_SYMBOL_STUBS size specified, print it. 146 if (Reserved2 != 0) 147 OS << ',' << Reserved2; 148 OS << '\n'; 149} 150 151bool MCSectionMachO::UseCodeAlign() const { 152 return hasAttribute(MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS); 153} 154 155/// StripSpaces - This removes leading and trailing spaces from the StringRef. 156static void StripSpaces(StringRef &Str) { 157 while (!Str.empty() && isspace(Str[0])) 158 Str = Str.substr(1); 159 while (!Str.empty() && isspace(Str.back())) 160 Str = Str.substr(0, Str.size()-1); 161} 162 163/// ParseSectionSpecifier - Parse the section specifier indicated by "Spec". 164/// This is a string that can appear after a .section directive in a mach-o 165/// flavored .s file. If successful, this fills in the specified Out 166/// parameters and returns an empty string. When an invalid section 167/// specifier is present, this returns a string indicating the problem. 168std::string MCSectionMachO::ParseSectionSpecifier(StringRef Spec, // In. 169 StringRef &Segment, // Out. 170 StringRef &Section, // Out. 171 unsigned &TAA, // Out. 172 unsigned &StubSize) { // Out. 173 // Find the first comma. 174 std::pair<StringRef, StringRef> Comma = Spec.split(','); 175 176 // If there is no comma, we fail. 177 if (Comma.second.empty()) 178 return "mach-o section specifier requires a segment and section " 179 "separated by a comma"; 180 181 // Capture segment, remove leading and trailing whitespace. 182 Segment = Comma.first; 183 StripSpaces(Segment); 184 185 // Verify that the segment is present and not too long. 186 if (Segment.empty() || Segment.size() > 16) 187 return "mach-o section specifier requires a segment whose length is " 188 "between 1 and 16 characters"; 189 190 // Split the section name off from any attributes if present. 191 Comma = Comma.second.split(','); 192 193 // Capture section, remove leading and trailing whitespace. 194 Section = Comma.first; 195 StripSpaces(Section); 196 197 // Verify that the section is present and not too long. 198 if (Section.empty() || Section.size() > 16) 199 return "mach-o section specifier requires a section whose length is " 200 "between 1 and 16 characters"; 201 202 // If there is no comma after the section, we're done. 203 TAA = 0; 204 StubSize = 0; 205 if (Comma.second.empty()) 206 return ""; 207 208 // Otherwise, we need to parse the section type and attributes. 209 Comma = Comma.second.split(','); 210 211 // Get the section type. 212 StringRef SectionType = Comma.first; 213 StripSpaces(SectionType); 214 215 // Figure out which section type it is. 216 unsigned TypeID; 217 for (TypeID = 0; TypeID !=MCSectionMachO::LAST_KNOWN_SECTION_TYPE+1; ++TypeID) 218 if (SectionTypeDescriptors[TypeID].AssemblerName && 219 SectionType == SectionTypeDescriptors[TypeID].AssemblerName) 220 break; 221 222 // If we didn't find the section type, reject it. 223 if (TypeID > MCSectionMachO::LAST_KNOWN_SECTION_TYPE) 224 return "mach-o section specifier uses an unknown section type"; 225 226 // Remember the TypeID. 227 TAA = TypeID; 228 229 // If we have no comma after the section type, there are no attributes. 230 if (Comma.second.empty()) { 231 // S_SYMBOL_STUBS always require a symbol stub size specifier. 232 if (TAA == MCSectionMachO::S_SYMBOL_STUBS) 233 return "mach-o section specifier of type 'symbol_stubs' requires a size " 234 "specifier"; 235 return ""; 236 } 237 238 // Otherwise, we do have some attributes. Split off the size specifier if 239 // present. 240 Comma = Comma.second.split(','); 241 StringRef Attrs = Comma.first; 242 243 // The attribute list is a '+' separated list of attributes. 244 std::pair<StringRef, StringRef> Plus = Attrs.split('+'); 245 246 while (1) { 247 StringRef Attr = Plus.first; 248 StripSpaces(Attr); 249 250 // Look up the attribute. 251 for (unsigned i = 0; ; ++i) { 252 if (SectionAttrDescriptors[i].AttrFlag == AttrFlagEnd) 253 return "mach-o section specifier has invalid attribute"; 254 255 if (SectionAttrDescriptors[i].AssemblerName && 256 Attr == SectionAttrDescriptors[i].AssemblerName) { 257 TAA |= SectionAttrDescriptors[i].AttrFlag; 258 break; 259 } 260 } 261 262 if (Plus.second.empty()) break; 263 Plus = Plus.second.split('+'); 264 }; 265 266 // Okay, we've parsed the section attributes, see if we have a stub size spec. 267 if (Comma.second.empty()) { 268 // S_SYMBOL_STUBS always require a symbol stub size specifier. 269 if (TAA == MCSectionMachO::S_SYMBOL_STUBS) 270 return "mach-o section specifier of type 'symbol_stubs' requires a size " 271 "specifier"; 272 return ""; 273 } 274 275 // If we have a stub size spec, we must have a sectiontype of S_SYMBOL_STUBS. 276 if ((TAA & MCSectionMachO::SECTION_TYPE) != MCSectionMachO::S_SYMBOL_STUBS) 277 return "mach-o section specifier cannot have a stub size specified because " 278 "it does not have type 'symbol_stubs'"; 279 280 // Okay, if we do, it must be a number. 281 StringRef StubSizeStr = Comma.second; 282 StripSpaces(StubSizeStr); 283 284 // Convert the stub size from a string to an integer. 285 if (StubSizeStr.getAsInteger(0, StubSize)) 286 return "mach-o section specifier has a malformed stub size"; 287 288 return ""; 289} 290