1 //===- lib/MC/MCContext.cpp - Machine Code Context ------------------------===// 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/MCContext.h" 11 #include "llvm/ADT/SmallString.h" 12 #include "llvm/ADT/Twine.h" 13 #include "llvm/MC/MCAsmInfo.h" 14 #include "llvm/MC/MCDwarf.h" 15 #include "llvm/MC/MCLabel.h" 16 #include "llvm/MC/MCObjectFileInfo.h" 17 #include "llvm/MC/MCRegisterInfo.h" 18 #include "llvm/MC/MCSectionCOFF.h" 19 #include "llvm/MC/MCSectionELF.h" 20 #include "llvm/MC/MCSectionMachO.h" 21 #include "llvm/MC/MCSymbol.h" 22 #include "llvm/Support/ELF.h" 23 #include "llvm/Support/ErrorHandling.h" 24 #include "llvm/Support/MemoryBuffer.h" 25 #include "llvm/Support/Signals.h" 26 #include "llvm/Support/SourceMgr.h" 27 using namespace llvm; 28 29 typedef StringMap<const MCSectionMachO*> MachOUniqueMapTy; 30 typedef StringMap<const MCSectionELF*> ELFUniqueMapTy; 31 typedef StringMap<const MCSectionCOFF*> COFFUniqueMapTy; 32 33 34 MCContext::MCContext(const MCAsmInfo &mai, const MCRegisterInfo &mri, 35 const MCObjectFileInfo *mofi, const SourceMgr *mgr, 36 bool DoAutoReset) : 37 SrcMgr(mgr), MAI(mai), MRI(mri), MOFI(mofi), 38 Allocator(), Symbols(Allocator), UsedNames(Allocator), 39 NextUniqueID(0), 40 CompilationDir(llvm::sys::Path::GetCurrentDirectory().str()), 41 CurrentDwarfLoc(0,0,0,DWARF2_FLAG_IS_STMT,0,0), 42 DwarfLocSeen(false), GenDwarfForAssembly(false), GenDwarfFileNumber(0), 43 AllowTemporaryLabels(true), DwarfCompileUnitID(0), AutoReset(DoAutoReset) { 44 45 MachOUniquingMap = 0; 46 ELFUniquingMap = 0; 47 COFFUniquingMap = 0; 48 49 SecureLogFile = getenv("AS_SECURE_LOG_FILE"); 50 SecureLog = 0; 51 SecureLogUsed = false; 52 53 if (SrcMgr && SrcMgr->getNumBuffers() > 0) 54 MainFileName = SrcMgr->getMemoryBuffer(0)->getBufferIdentifier(); 55 else 56 MainFileName = ""; 57 } 58 59 MCContext::~MCContext() { 60 61 if (AutoReset) 62 reset(); 63 64 // NOTE: The symbols are all allocated out of a bump pointer allocator, 65 // we don't need to free them here. 66 67 // If the stream for the .secure_log_unique directive was created free it. 68 delete (raw_ostream*)SecureLog; 69 } 70 71 //===----------------------------------------------------------------------===// 72 // Module Lifetime Management 73 //===----------------------------------------------------------------------===// 74 75 void MCContext::reset() { 76 UsedNames.clear(); 77 Symbols.clear(); 78 Allocator.Reset(); 79 Instances.clear(); 80 MCDwarfFilesCUMap.clear(); 81 MCDwarfDirsCUMap.clear(); 82 MCGenDwarfLabelEntries.clear(); 83 DwarfDebugFlags = StringRef(); 84 MCLineSections.clear(); 85 MCLineSectionOrder.clear(); 86 DwarfCompileUnitID = 0; 87 MCLineTableSymbols.clear(); 88 CurrentDwarfLoc = MCDwarfLoc(0,0,0,DWARF2_FLAG_IS_STMT,0,0); 89 90 // If we have the MachO uniquing map, free it. 91 delete (MachOUniqueMapTy*)MachOUniquingMap; 92 delete (ELFUniqueMapTy*)ELFUniquingMap; 93 delete (COFFUniqueMapTy*)COFFUniquingMap; 94 MachOUniquingMap = 0; 95 ELFUniquingMap = 0; 96 COFFUniquingMap = 0; 97 98 NextUniqueID = 0; 99 AllowTemporaryLabels = true; 100 DwarfLocSeen = false; 101 GenDwarfForAssembly = false; 102 GenDwarfFileNumber = 0; 103 } 104 105 //===----------------------------------------------------------------------===// 106 // Symbol Manipulation 107 //===----------------------------------------------------------------------===// 108 109 MCSymbol *MCContext::GetOrCreateSymbol(StringRef Name) { 110 assert(!Name.empty() && "Normal symbols cannot be unnamed!"); 111 112 // Do the lookup and get the entire StringMapEntry. We want access to the 113 // key if we are creating the entry. 114 StringMapEntry<MCSymbol*> &Entry = Symbols.GetOrCreateValue(Name); 115 MCSymbol *Sym = Entry.getValue(); 116 117 if (Sym) 118 return Sym; 119 120 Sym = CreateSymbol(Name); 121 Entry.setValue(Sym); 122 return Sym; 123 } 124 125 MCSymbol *MCContext::CreateSymbol(StringRef Name) { 126 // Determine whether this is an assembler temporary or normal label, if used. 127 bool isTemporary = false; 128 if (AllowTemporaryLabels) 129 isTemporary = Name.startswith(MAI.getPrivateGlobalPrefix()); 130 131 StringMapEntry<bool> *NameEntry = &UsedNames.GetOrCreateValue(Name); 132 if (NameEntry->getValue()) { 133 assert(isTemporary && "Cannot rename non temporary symbols"); 134 SmallString<128> NewName = Name; 135 do { 136 NewName.resize(Name.size()); 137 raw_svector_ostream(NewName) << NextUniqueID++; 138 NameEntry = &UsedNames.GetOrCreateValue(NewName); 139 } while (NameEntry->getValue()); 140 } 141 NameEntry->setValue(true); 142 143 // Ok, the entry doesn't already exist. Have the MCSymbol object itself refer 144 // to the copy of the string that is embedded in the UsedNames entry. 145 MCSymbol *Result = new (*this) MCSymbol(NameEntry->getKey(), isTemporary); 146 147 return Result; 148 } 149 150 MCSymbol *MCContext::GetOrCreateSymbol(const Twine &Name) { 151 SmallString<128> NameSV; 152 Name.toVector(NameSV); 153 return GetOrCreateSymbol(NameSV.str()); 154 } 155 156 MCSymbol *MCContext::CreateTempSymbol() { 157 SmallString<128> NameSV; 158 raw_svector_ostream(NameSV) 159 << MAI.getPrivateGlobalPrefix() << "tmp" << NextUniqueID++; 160 return CreateSymbol(NameSV); 161 } 162 163 unsigned MCContext::NextInstance(int64_t LocalLabelVal) { 164 MCLabel *&Label = Instances[LocalLabelVal]; 165 if (!Label) 166 Label = new (*this) MCLabel(0); 167 return Label->incInstance(); 168 } 169 170 unsigned MCContext::GetInstance(int64_t LocalLabelVal) { 171 MCLabel *&Label = Instances[LocalLabelVal]; 172 if (!Label) 173 Label = new (*this) MCLabel(0); 174 return Label->getInstance(); 175 } 176 177 MCSymbol *MCContext::CreateDirectionalLocalSymbol(int64_t LocalLabelVal) { 178 return GetOrCreateSymbol(Twine(MAI.getPrivateGlobalPrefix()) + 179 Twine(LocalLabelVal) + 180 "\2" + 181 Twine(NextInstance(LocalLabelVal))); 182 } 183 MCSymbol *MCContext::GetDirectionalLocalSymbol(int64_t LocalLabelVal, 184 int bORf) { 185 return GetOrCreateSymbol(Twine(MAI.getPrivateGlobalPrefix()) + 186 Twine(LocalLabelVal) + 187 "\2" + 188 Twine(GetInstance(LocalLabelVal) + bORf)); 189 } 190 191 MCSymbol *MCContext::LookupSymbol(StringRef Name) const { 192 return Symbols.lookup(Name); 193 } 194 195 MCSymbol *MCContext::LookupSymbol(const Twine &Name) const { 196 SmallString<128> NameSV; 197 Name.toVector(NameSV); 198 return LookupSymbol(NameSV.str()); 199 } 200 201 //===----------------------------------------------------------------------===// 202 // Section Management 203 //===----------------------------------------------------------------------===// 204 205 const MCSectionMachO *MCContext:: 206 getMachOSection(StringRef Segment, StringRef Section, 207 unsigned TypeAndAttributes, 208 unsigned Reserved2, SectionKind Kind) { 209 210 // We unique sections by their segment/section pair. The returned section 211 // may not have the same flags as the requested section, if so this should be 212 // diagnosed by the client as an error. 213 214 // Create the map if it doesn't already exist. 215 if (MachOUniquingMap == 0) 216 MachOUniquingMap = new MachOUniqueMapTy(); 217 MachOUniqueMapTy &Map = *(MachOUniqueMapTy*)MachOUniquingMap; 218 219 // Form the name to look up. 220 SmallString<64> Name; 221 Name += Segment; 222 Name.push_back(','); 223 Name += Section; 224 225 // Do the lookup, if we have a hit, return it. 226 const MCSectionMachO *&Entry = Map[Name.str()]; 227 if (Entry) return Entry; 228 229 // Otherwise, return a new section. 230 return Entry = new (*this) MCSectionMachO(Segment, Section, TypeAndAttributes, 231 Reserved2, Kind); 232 } 233 234 const MCSectionELF *MCContext:: 235 getELFSection(StringRef Section, unsigned Type, unsigned Flags, 236 SectionKind Kind) { 237 return getELFSection(Section, Type, Flags, Kind, 0, ""); 238 } 239 240 const MCSectionELF *MCContext:: 241 getELFSection(StringRef Section, unsigned Type, unsigned Flags, 242 SectionKind Kind, unsigned EntrySize, StringRef Group) { 243 if (ELFUniquingMap == 0) 244 ELFUniquingMap = new ELFUniqueMapTy(); 245 ELFUniqueMapTy &Map = *(ELFUniqueMapTy*)ELFUniquingMap; 246 247 // Do the lookup, if we have a hit, return it. 248 StringMapEntry<const MCSectionELF*> &Entry = Map.GetOrCreateValue(Section); 249 if (Entry.getValue()) return Entry.getValue(); 250 251 // Possibly refine the entry size first. 252 if (!EntrySize) { 253 EntrySize = MCSectionELF::DetermineEntrySize(Kind); 254 } 255 256 MCSymbol *GroupSym = NULL; 257 if (!Group.empty()) 258 GroupSym = GetOrCreateSymbol(Group); 259 260 MCSectionELF *Result = new (*this) MCSectionELF(Entry.getKey(), Type, Flags, 261 Kind, EntrySize, GroupSym); 262 Entry.setValue(Result); 263 return Result; 264 } 265 266 const MCSectionELF *MCContext::CreateELFGroupSection() { 267 MCSectionELF *Result = 268 new (*this) MCSectionELF(".group", ELF::SHT_GROUP, 0, 269 SectionKind::getReadOnly(), 4, NULL); 270 return Result; 271 } 272 273 const MCSection *MCContext::getCOFFSection(StringRef Section, 274 unsigned Characteristics, 275 int Selection, 276 SectionKind Kind) { 277 if (COFFUniquingMap == 0) 278 COFFUniquingMap = new COFFUniqueMapTy(); 279 COFFUniqueMapTy &Map = *(COFFUniqueMapTy*)COFFUniquingMap; 280 281 // Do the lookup, if we have a hit, return it. 282 StringMapEntry<const MCSectionCOFF*> &Entry = Map.GetOrCreateValue(Section); 283 if (Entry.getValue()) return Entry.getValue(); 284 285 MCSectionCOFF *Result = new (*this) MCSectionCOFF(Entry.getKey(), 286 Characteristics, 287 Selection, Kind); 288 289 Entry.setValue(Result); 290 return Result; 291 } 292 293 //===----------------------------------------------------------------------===// 294 // Dwarf Management 295 //===----------------------------------------------------------------------===// 296 297 /// GetDwarfFile - takes a file name an number to place in the dwarf file and 298 /// directory tables. If the file number has already been allocated it is an 299 /// error and zero is returned and the client reports the error, else the 300 /// allocated file number is returned. The file numbers may be in any order. 301 unsigned MCContext::GetDwarfFile(StringRef Directory, StringRef FileName, 302 unsigned FileNumber, unsigned CUID) { 303 // TODO: a FileNumber of zero says to use the next available file number. 304 // Note: in GenericAsmParser::ParseDirectiveFile() FileNumber was checked 305 // to not be less than one. This needs to be change to be not less than zero. 306 307 SmallVectorImpl<MCDwarfFile *>& MCDwarfFiles = MCDwarfFilesCUMap[CUID]; 308 SmallVectorImpl<StringRef>& MCDwarfDirs = MCDwarfDirsCUMap[CUID]; 309 // Make space for this FileNumber in the MCDwarfFiles vector if needed. 310 if (FileNumber >= MCDwarfFiles.size()) { 311 MCDwarfFiles.resize(FileNumber + 1); 312 } else { 313 MCDwarfFile *&ExistingFile = MCDwarfFiles[FileNumber]; 314 if (ExistingFile) 315 // It is an error to use see the same number more than once. 316 return 0; 317 } 318 319 // Get the new MCDwarfFile slot for this FileNumber. 320 MCDwarfFile *&File = MCDwarfFiles[FileNumber]; 321 322 if (Directory.empty()) { 323 // Separate the directory part from the basename of the FileName. 324 StringRef tFileName = sys::path::filename(FileName); 325 if (!tFileName.empty()) { 326 Directory = sys::path::parent_path(FileName); 327 if (!Directory.empty()) 328 FileName = tFileName; 329 } 330 } 331 332 // Find or make a entry in the MCDwarfDirs vector for this Directory. 333 // Capture directory name. 334 unsigned DirIndex; 335 if (Directory.empty()) { 336 // For FileNames with no directories a DirIndex of 0 is used. 337 DirIndex = 0; 338 } else { 339 DirIndex = 0; 340 for (unsigned End = MCDwarfDirs.size(); DirIndex < End; DirIndex++) { 341 if (Directory == MCDwarfDirs[DirIndex]) 342 break; 343 } 344 if (DirIndex >= MCDwarfDirs.size()) { 345 char *Buf = static_cast<char *>(Allocate(Directory.size())); 346 memcpy(Buf, Directory.data(), Directory.size()); 347 MCDwarfDirs.push_back(StringRef(Buf, Directory.size())); 348 } 349 // The DirIndex is one based, as DirIndex of 0 is used for FileNames with 350 // no directories. MCDwarfDirs[] is unlike MCDwarfFiles[] in that the 351 // directory names are stored at MCDwarfDirs[DirIndex-1] where FileNames 352 // are stored at MCDwarfFiles[FileNumber].Name . 353 DirIndex++; 354 } 355 356 // Now make the MCDwarfFile entry and place it in the slot in the MCDwarfFiles 357 // vector. 358 char *Buf = static_cast<char *>(Allocate(FileName.size())); 359 memcpy(Buf, FileName.data(), FileName.size()); 360 File = new (*this) MCDwarfFile(StringRef(Buf, FileName.size()), DirIndex); 361 362 // return the allocated FileNumber. 363 return FileNumber; 364 } 365 366 /// isValidDwarfFileNumber - takes a dwarf file number and returns true if it 367 /// currently is assigned and false otherwise. 368 bool MCContext::isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID) { 369 SmallVectorImpl<MCDwarfFile *>& MCDwarfFiles = MCDwarfFilesCUMap[CUID]; 370 if(FileNumber == 0 || FileNumber >= MCDwarfFiles.size()) 371 return false; 372 373 return MCDwarfFiles[FileNumber] != 0; 374 } 375 376 void MCContext::FatalError(SMLoc Loc, const Twine &Msg) { 377 // If we have a source manager and a location, use it. Otherwise just 378 // use the generic report_fatal_error(). 379 if (!SrcMgr || Loc == SMLoc()) 380 report_fatal_error(Msg); 381 382 // Use the source manager to print the message. 383 SrcMgr->PrintMessage(Loc, SourceMgr::DK_Error, Msg); 384 385 // If we reached here, we are failing ungracefully. Run the interrupt handlers 386 // to make sure any special cleanups get done, in particular that we remove 387 // files registered with RemoveFileOnSignal. 388 sys::RunInterruptHandlers(); 389 exit(1); 390 } 391