MCSectionMachO.cpp revision 9a744e38607bc3046dffea56efec0b2dfc51d5e4
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_bss", "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 151/// StripSpaces - This removes leading and trailing spaces from the StringRef. 152static void StripSpaces(StringRef &Str) { 153 while (!Str.empty() && isspace(Str[0])) 154 Str = Str.substr(1); 155 while (!Str.empty() && isspace(Str.back())) 156 Str = Str.substr(0, Str.size()-1); 157} 158 159/// ParseSectionSpecifier - Parse the section specifier indicated by "Spec". 160/// This is a string that can appear after a .section directive in a mach-o 161/// flavored .s file. If successful, this fills in the specified Out 162/// parameters and returns an empty string. When an invalid section 163/// specifier is present, this returns a string indicating the problem. 164std::string MCSectionMachO::ParseSectionSpecifier(StringRef Spec, // In. 165 StringRef &Segment, // Out. 166 StringRef &Section, // Out. 167 unsigned &TAA, // Out. 168 unsigned &StubSize) { // Out. 169 // Find the first comma. 170 std::pair<StringRef, StringRef> Comma = Spec.split(','); 171 172 // If there is no comma, we fail. 173 if (Comma.second.empty()) 174 return "mach-o section specifier requires a segment and section " 175 "separated by a comma"; 176 177 // Capture segment, remove leading and trailing whitespace. 178 Segment = Comma.first; 179 StripSpaces(Segment); 180 181 // Verify that the segment is present and not too long. 182 if (Segment.empty() || Segment.size() > 16) 183 return "mach-o section specifier requires a segment whose length is " 184 "between 1 and 16 characters"; 185 186 // Split the section name off from any attributes if present. 187 Comma = Comma.second.split(','); 188 189 // Capture section, remove leading and trailing whitespace. 190 Section = Comma.first; 191 StripSpaces(Section); 192 193 // Verify that the section is present and not too long. 194 if (Section.empty() || Section.size() > 16) 195 return "mach-o section specifier requires a section whose length is " 196 "between 1 and 16 characters"; 197 198 // If there is no comma after the section, we're done. 199 TAA = 0; 200 StubSize = 0; 201 if (Comma.second.empty()) 202 return ""; 203 204 // Otherwise, we need to parse the section type and attributes. 205 Comma = Comma.second.split(','); 206 207 // Get the section type. 208 StringRef SectionType = Comma.first; 209 StripSpaces(SectionType); 210 211 // Figure out which section type it is. 212 unsigned TypeID; 213 for (TypeID = 0; TypeID !=MCSectionMachO::LAST_KNOWN_SECTION_TYPE+1; ++TypeID) 214 if (SectionTypeDescriptors[TypeID].AssemblerName && 215 SectionType == SectionTypeDescriptors[TypeID].AssemblerName) 216 break; 217 218 // If we didn't find the section type, reject it. 219 if (TypeID > MCSectionMachO::LAST_KNOWN_SECTION_TYPE) 220 return "mach-o section specifier uses an unknown section type"; 221 222 // Remember the TypeID. 223 TAA = TypeID; 224 225 // If we have no comma after the section type, there are no attributes. 226 if (Comma.second.empty()) { 227 // S_SYMBOL_STUBS always require a symbol stub size specifier. 228 if (TAA == MCSectionMachO::S_SYMBOL_STUBS) 229 return "mach-o section specifier of type 'symbol_stubs' requires a size " 230 "specifier"; 231 return ""; 232 } 233 234 // Otherwise, we do have some attributes. Split off the size specifier if 235 // present. 236 Comma = Comma.second.split(','); 237 StringRef Attrs = Comma.first; 238 239 // The attribute list is a '+' separated list of attributes. 240 std::pair<StringRef, StringRef> Plus = Attrs.split('+'); 241 242 while (1) { 243 StringRef Attr = Plus.first; 244 StripSpaces(Attr); 245 246 // Look up the attribute. 247 for (unsigned i = 0; ; ++i) { 248 if (SectionAttrDescriptors[i].AttrFlag == AttrFlagEnd) 249 return "mach-o section specifier has invalid attribute"; 250 251 if (SectionAttrDescriptors[i].AssemblerName && 252 Attr == SectionAttrDescriptors[i].AssemblerName) { 253 TAA |= SectionAttrDescriptors[i].AttrFlag; 254 break; 255 } 256 } 257 258 if (Plus.second.empty()) break; 259 Plus = Plus.second.split('+'); 260 }; 261 262 // Okay, we've parsed the section attributes, see if we have a stub size spec. 263 if (Comma.second.empty()) { 264 // S_SYMBOL_STUBS always require a symbol stub size specifier. 265 if (TAA == MCSectionMachO::S_SYMBOL_STUBS) 266 return "mach-o section specifier of type 'symbol_stubs' requires a size " 267 "specifier"; 268 return ""; 269 } 270 271 // If we have a stub size spec, we must have a sectiontype of S_SYMBOL_STUBS. 272 if ((TAA & MCSectionMachO::SECTION_TYPE) != MCSectionMachO::S_SYMBOL_STUBS) 273 return "mach-o section specifier cannot have a stub size specified because " 274 "it does not have type 'symbol_stubs'"; 275 276 // Okay, if we do, it must be a number. 277 StringRef StubSizeStr = Comma.second; 278 StripSpaces(StubSizeStr); 279 280 // Convert the stub size from a string to an integer. 281 if (StubSizeStr.getAsInteger(0, StubSize)) 282 return "mach-o section specifier has a malformed stub size"; 283 284 return ""; 285} 286 287