1 //===- MCContext.h - Machine Code Context -----------------------*- 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 #ifndef LLVM_MC_MCCONTEXT_H 11 #define LLVM_MC_MCCONTEXT_H 12 13 #include "llvm/ADT/DenseMap.h" 14 #include "llvm/ADT/SetVector.h" 15 #include "llvm/ADT/SmallString.h" 16 #include "llvm/ADT/SmallVector.h" 17 #include "llvm/ADT/StringMap.h" 18 #include "llvm/MC/MCDwarf.h" 19 #include "llvm/MC/MCStreamer.h" 20 #include "llvm/MC/SectionKind.h" 21 #include "llvm/Support/Allocator.h" 22 #include "llvm/Support/Compiler.h" 23 #include "llvm/Support/raw_ostream.h" 24 #include <map> 25 #include <tuple> 26 #include <vector> // FIXME: Shouldn't be needed. 27 28 namespace llvm { 29 class MCAsmInfo; 30 class MCExpr; 31 class MCSection; 32 class MCSymbol; 33 class MCLabel; 34 struct MCDwarfFile; 35 class MCDwarfLoc; 36 class MCObjectFileInfo; 37 class MCRegisterInfo; 38 class MCLineSection; 39 class SMLoc; 40 class StringRef; 41 class Twine; 42 class MCSectionMachO; 43 class MCSectionELF; 44 class MCSectionCOFF; 45 46 /// MCContext - Context object for machine code objects. This class owns all 47 /// of the sections that it creates. 48 /// 49 class MCContext { 50 MCContext(const MCContext&) LLVM_DELETED_FUNCTION; 51 MCContext &operator=(const MCContext&) LLVM_DELETED_FUNCTION; 52 public: 53 typedef StringMap<MCSymbol*, BumpPtrAllocator&> SymbolTable; 54 private: 55 /// The SourceMgr for this object, if any. 56 const SourceMgr *SrcMgr; 57 58 /// The MCAsmInfo for this target. 59 const MCAsmInfo *MAI; 60 61 /// The MCRegisterInfo for this target. 62 const MCRegisterInfo *MRI; 63 64 /// The MCObjectFileInfo for this target. 65 const MCObjectFileInfo *MOFI; 66 67 /// Allocator - Allocator object used for creating machine code objects. 68 /// 69 /// We use a bump pointer allocator to avoid the need to track all allocated 70 /// objects. 71 BumpPtrAllocator Allocator; 72 73 /// Symbols - Bindings of names to symbols. 74 SymbolTable Symbols; 75 76 /// A maping from a local label number and an instance count to a symbol. 77 /// For example, in the assembly 78 /// 1: 79 /// 2: 80 /// 1: 81 /// We have three labels represented by the pairs (1, 0), (2, 0) and (1, 1) 82 DenseMap<std::pair<unsigned, unsigned>, MCSymbol*> LocalSymbols; 83 84 /// UsedNames - Keeps tracks of names that were used both for used declared 85 /// and artificial symbols. 86 StringMap<bool, BumpPtrAllocator&> UsedNames; 87 88 /// NextUniqueID - The next ID to dole out to an unnamed assembler temporary 89 /// symbol. 90 unsigned NextUniqueID; 91 92 /// Instances of directional local labels. 93 DenseMap<unsigned, MCLabel *> Instances; 94 /// NextInstance() creates the next instance of the directional local label 95 /// for the LocalLabelVal and adds it to the map if needed. 96 unsigned NextInstance(unsigned LocalLabelVal); 97 /// GetInstance() gets the current instance of the directional local label 98 /// for the LocalLabelVal and adds it to the map if needed. 99 unsigned GetInstance(unsigned LocalLabelVal); 100 101 /// The file name of the log file from the environment variable 102 /// AS_SECURE_LOG_FILE. Which must be set before the .secure_log_unique 103 /// directive is used or it is an error. 104 char *SecureLogFile; 105 /// The stream that gets written to for the .secure_log_unique directive. 106 raw_ostream *SecureLog; 107 /// Boolean toggled when .secure_log_unique / .secure_log_reset is seen to 108 /// catch errors if .secure_log_unique appears twice without 109 /// .secure_log_reset appearing between them. 110 bool SecureLogUsed; 111 112 /// The compilation directory to use for DW_AT_comp_dir. 113 SmallString<128> CompilationDir; 114 115 /// The main file name if passed in explicitly. 116 std::string MainFileName; 117 118 /// The dwarf file and directory tables from the dwarf .file directive. 119 /// We now emit a line table for each compile unit. To reduce the prologue 120 /// size of each line table, the files and directories used by each compile 121 /// unit are separated. 122 std::map<unsigned, MCDwarfLineTable> MCDwarfLineTablesCUMap; 123 124 /// The current dwarf line information from the last dwarf .loc directive. 125 MCDwarfLoc CurrentDwarfLoc; 126 bool DwarfLocSeen; 127 128 /// Generate dwarf debugging info for assembly source files. 129 bool GenDwarfForAssembly; 130 131 /// The current dwarf file number when generate dwarf debugging info for 132 /// assembly source files. 133 unsigned GenDwarfFileNumber; 134 135 /// Symbols created for the start and end of each section, used for 136 /// generating the .debug_ranges and .debug_aranges sections. 137 MapVector<const MCSection *, std::pair<MCSymbol *, MCSymbol *> > 138 SectionStartEndSyms; 139 140 /// The information gathered from labels that will have dwarf label 141 /// entries when generating dwarf assembly source files. 142 std::vector<MCGenDwarfLabelEntry> MCGenDwarfLabelEntries; 143 144 /// The string to embed in the debug information for the compile unit, if 145 /// non-empty. 146 StringRef DwarfDebugFlags; 147 148 /// The string to embed in as the dwarf AT_producer for the compile unit, if 149 /// non-empty. 150 StringRef DwarfDebugProducer; 151 152 /// The maximum version of dwarf that we should emit. 153 uint16_t DwarfVersion; 154 155 /// Honor temporary labels, this is useful for debugging semantic 156 /// differences between temporary and non-temporary labels (primarily on 157 /// Darwin). 158 bool AllowTemporaryLabels; 159 160 /// The Compile Unit ID that we are currently processing. 161 unsigned DwarfCompileUnitID; 162 163 typedef std::pair<std::string, std::string> SectionGroupPair; 164 typedef std::tuple<std::string, std::string, int> SectionGroupTriple; 165 166 StringMap<const MCSectionMachO*> MachOUniquingMap; 167 std::map<SectionGroupPair, const MCSectionELF *> ELFUniquingMap; 168 std::map<SectionGroupTriple, const MCSectionCOFF *> COFFUniquingMap; 169 170 /// Do automatic reset in destructor 171 bool AutoReset; 172 173 MCSymbol *CreateSymbol(StringRef Name); 174 175 MCSymbol *getOrCreateDirectionalLocalSymbol(unsigned LocalLabelVal, 176 unsigned Instance); 177 178 public: 179 explicit MCContext(const MCAsmInfo *MAI, const MCRegisterInfo *MRI, 180 const MCObjectFileInfo *MOFI, 181 const SourceMgr *Mgr = nullptr, bool DoAutoReset = true); 182 ~MCContext(); 183 184 const SourceMgr *getSourceManager() const { return SrcMgr; } 185 186 const MCAsmInfo *getAsmInfo() const { return MAI; } 187 188 const MCRegisterInfo *getRegisterInfo() const { return MRI; } 189 190 const MCObjectFileInfo *getObjectFileInfo() const { return MOFI; } 191 192 void setAllowTemporaryLabels(bool Value) { AllowTemporaryLabels = Value; } 193 194 /// @name Module Lifetime Management 195 /// @{ 196 197 /// reset - return object to right after construction state to prepare 198 /// to process a new module 199 void reset(); 200 201 /// @} 202 203 /// @name Symbol Management 204 /// @{ 205 206 /// CreateLinkerPrivateTempSymbol - Create and return a new linker temporary 207 /// symbol with a unique but unspecified name. 208 MCSymbol *CreateLinkerPrivateTempSymbol(); 209 210 /// CreateTempSymbol - Create and return a new assembler temporary symbol 211 /// with a unique but unspecified name. 212 MCSymbol *CreateTempSymbol(); 213 214 /// getUniqueSymbolID() - Return a unique identifier for use in constructing 215 /// symbol names. 216 unsigned getUniqueSymbolID() { return NextUniqueID++; } 217 218 /// Create the definition of a directional local symbol for numbered label 219 /// (used for "1:" definitions). 220 MCSymbol *CreateDirectionalLocalSymbol(unsigned LocalLabelVal); 221 222 /// Create and return a directional local symbol for numbered label (used 223 /// for "1b" or 1f" references). 224 MCSymbol *GetDirectionalLocalSymbol(unsigned LocalLabelVal, bool Before); 225 226 /// GetOrCreateSymbol - Lookup the symbol inside with the specified 227 /// @p Name. If it exists, return it. If not, create a forward 228 /// reference and return it. 229 /// 230 /// @param Name - The symbol name, which must be unique across all symbols. 231 MCSymbol *GetOrCreateSymbol(StringRef Name); 232 MCSymbol *GetOrCreateSymbol(const Twine &Name); 233 234 /// LookupSymbol - Get the symbol for \p Name, or null. 235 MCSymbol *LookupSymbol(StringRef Name) const; 236 MCSymbol *LookupSymbol(const Twine &Name) const; 237 238 /// getSymbols - Get a reference for the symbol table for clients that 239 /// want to, for example, iterate over all symbols. 'const' because we 240 /// still want any modifications to the table itself to use the MCContext 241 /// APIs. 242 const SymbolTable &getSymbols() const { 243 return Symbols; 244 } 245 246 /// @} 247 248 /// @name Section Management 249 /// @{ 250 251 /// getMachOSection - Return the MCSection for the specified mach-o section. 252 /// This requires the operands to be valid. 253 const MCSectionMachO *getMachOSection(StringRef Segment, 254 StringRef Section, 255 unsigned TypeAndAttributes, 256 unsigned Reserved2, 257 SectionKind K); 258 const MCSectionMachO *getMachOSection(StringRef Segment, 259 StringRef Section, 260 unsigned TypeAndAttributes, 261 SectionKind K) { 262 return getMachOSection(Segment, Section, TypeAndAttributes, 0, K); 263 } 264 265 const MCSectionELF *getELFSection(StringRef Section, unsigned Type, 266 unsigned Flags, SectionKind Kind); 267 268 const MCSectionELF *getELFSection(StringRef Section, unsigned Type, 269 unsigned Flags, SectionKind Kind, 270 unsigned EntrySize, StringRef Group); 271 272 void renameELFSection(const MCSectionELF *Section, StringRef Name); 273 274 const MCSectionELF *CreateELFGroupSection(); 275 276 const MCSectionCOFF *getCOFFSection(StringRef Section, 277 unsigned Characteristics, 278 SectionKind Kind, 279 StringRef COMDATSymName, int Selection); 280 281 const MCSectionCOFF *getCOFFSection(StringRef Section, 282 unsigned Characteristics, 283 SectionKind Kind); 284 285 const MCSectionCOFF *getCOFFSection(StringRef Section); 286 287 /// @} 288 289 /// @name Dwarf Management 290 /// @{ 291 292 /// \brief Get the compilation directory for DW_AT_comp_dir 293 /// This can be overridden by clients which want to control the reported 294 /// compilation directory and have it be something other than the current 295 /// working directory. 296 /// Returns an empty string if the current directory cannot be determined. 297 StringRef getCompilationDir() const { return CompilationDir; } 298 299 /// \brief Set the compilation directory for DW_AT_comp_dir 300 /// Override the default (CWD) compilation directory. 301 void setCompilationDir(StringRef S) { CompilationDir = S.str(); } 302 303 /// \brief Get the main file name for use in error messages and debug 304 /// info. This can be set to ensure we've got the correct file name 305 /// after preprocessing or for -save-temps. 306 const std::string &getMainFileName() const { return MainFileName; } 307 308 /// \brief Set the main file name and override the default. 309 void setMainFileName(StringRef S) { MainFileName = S; } 310 311 /// GetDwarfFile - creates an entry in the dwarf file and directory tables. 312 unsigned GetDwarfFile(StringRef Directory, StringRef FileName, 313 unsigned FileNumber, unsigned CUID); 314 315 bool isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID = 0); 316 317 const std::map<unsigned, MCDwarfLineTable> &getMCDwarfLineTables() const { 318 return MCDwarfLineTablesCUMap; 319 } 320 321 MCDwarfLineTable &getMCDwarfLineTable(unsigned CUID) { 322 return MCDwarfLineTablesCUMap[CUID]; 323 } 324 325 const MCDwarfLineTable &getMCDwarfLineTable(unsigned CUID) const { 326 auto I = MCDwarfLineTablesCUMap.find(CUID); 327 assert(I != MCDwarfLineTablesCUMap.end()); 328 return I->second; 329 } 330 331 const SmallVectorImpl<MCDwarfFile> &getMCDwarfFiles(unsigned CUID = 0) { 332 return getMCDwarfLineTable(CUID).getMCDwarfFiles(); 333 } 334 const SmallVectorImpl<std::string> &getMCDwarfDirs(unsigned CUID = 0) { 335 return getMCDwarfLineTable(CUID).getMCDwarfDirs(); 336 } 337 338 bool hasMCLineSections() const { 339 for (const auto &Table : MCDwarfLineTablesCUMap) 340 if (!Table.second.getMCDwarfFiles().empty() || Table.second.getLabel()) 341 return true; 342 return false; 343 } 344 unsigned getDwarfCompileUnitID() { 345 return DwarfCompileUnitID; 346 } 347 void setDwarfCompileUnitID(unsigned CUIndex) { 348 DwarfCompileUnitID = CUIndex; 349 } 350 void setMCLineTableCompilationDir(unsigned CUID, StringRef CompilationDir) { 351 getMCDwarfLineTable(CUID).setCompilationDir(CompilationDir); 352 } 353 354 /// setCurrentDwarfLoc - saves the information from the currently parsed 355 /// dwarf .loc directive and sets DwarfLocSeen. When the next instruction 356 /// is assembled an entry in the line number table with this information and 357 /// the address of the instruction will be created. 358 void setCurrentDwarfLoc(unsigned FileNum, unsigned Line, unsigned Column, 359 unsigned Flags, unsigned Isa, 360 unsigned Discriminator) { 361 CurrentDwarfLoc.setFileNum(FileNum); 362 CurrentDwarfLoc.setLine(Line); 363 CurrentDwarfLoc.setColumn(Column); 364 CurrentDwarfLoc.setFlags(Flags); 365 CurrentDwarfLoc.setIsa(Isa); 366 CurrentDwarfLoc.setDiscriminator(Discriminator); 367 DwarfLocSeen = true; 368 } 369 void ClearDwarfLocSeen() { DwarfLocSeen = false; } 370 371 bool getDwarfLocSeen() { return DwarfLocSeen; } 372 const MCDwarfLoc &getCurrentDwarfLoc() { return CurrentDwarfLoc; } 373 374 bool getGenDwarfForAssembly() { return GenDwarfForAssembly; } 375 void setGenDwarfForAssembly(bool Value) { GenDwarfForAssembly = Value; } 376 unsigned getGenDwarfFileNumber() { return GenDwarfFileNumber; } 377 void setGenDwarfFileNumber(unsigned FileNumber) { 378 GenDwarfFileNumber = FileNumber; 379 } 380 MapVector<const MCSection *, std::pair<MCSymbol *, MCSymbol *> > & 381 getGenDwarfSectionSyms() { 382 return SectionStartEndSyms; 383 } 384 std::pair<MapVector<const MCSection *, 385 std::pair<MCSymbol *, MCSymbol *> >::iterator, 386 bool> 387 addGenDwarfSection(const MCSection *Sec) { 388 return SectionStartEndSyms.insert( 389 std::make_pair(Sec, std::make_pair(nullptr, nullptr))); 390 } 391 void finalizeDwarfSections(MCStreamer &MCOS); 392 const std::vector<MCGenDwarfLabelEntry> &getMCGenDwarfLabelEntries() const { 393 return MCGenDwarfLabelEntries; 394 } 395 void addMCGenDwarfLabelEntry(const MCGenDwarfLabelEntry &E) { 396 MCGenDwarfLabelEntries.push_back(E); 397 } 398 399 void setDwarfDebugFlags(StringRef S) { DwarfDebugFlags = S; } 400 StringRef getDwarfDebugFlags() { return DwarfDebugFlags; } 401 402 void setDwarfDebugProducer(StringRef S) { DwarfDebugProducer = S; } 403 StringRef getDwarfDebugProducer() { return DwarfDebugProducer; } 404 405 void setDwarfVersion(uint16_t v) { DwarfVersion = v; } 406 uint16_t getDwarfVersion() const { return DwarfVersion; } 407 408 /// @} 409 410 char *getSecureLogFile() { return SecureLogFile; } 411 raw_ostream *getSecureLog() { return SecureLog; } 412 bool getSecureLogUsed() { return SecureLogUsed; } 413 void setSecureLog(raw_ostream *Value) { 414 SecureLog = Value; 415 } 416 void setSecureLogUsed(bool Value) { 417 SecureLogUsed = Value; 418 } 419 420 void *Allocate(unsigned Size, unsigned Align = 8) { 421 return Allocator.Allocate(Size, Align); 422 } 423 void Deallocate(void *Ptr) { 424 } 425 426 // Unrecoverable error has occurred. Display the best diagnostic we can 427 // and bail via exit(1). For now, most MC backend errors are unrecoverable. 428 // FIXME: We should really do something about that. 429 LLVM_ATTRIBUTE_NORETURN void FatalError(SMLoc L, const Twine &Msg) const; 430 }; 431 432 } // end namespace llvm 433 434 // operator new and delete aren't allowed inside namespaces. 435 // The throw specifications are mandated by the standard. 436 /// @brief Placement new for using the MCContext's allocator. 437 /// 438 /// This placement form of operator new uses the MCContext's allocator for 439 /// obtaining memory. It is a non-throwing new, which means that it returns 440 /// null on error. (If that is what the allocator does. The current does, so if 441 /// this ever changes, this operator will have to be changed, too.) 442 /// Usage looks like this (assuming there's an MCContext 'Context' in scope): 443 /// @code 444 /// // Default alignment (16) 445 /// IntegerLiteral *Ex = new (Context) IntegerLiteral(arguments); 446 /// // Specific alignment 447 /// IntegerLiteral *Ex2 = new (Context, 8) IntegerLiteral(arguments); 448 /// @endcode 449 /// Please note that you cannot use delete on the pointer; it must be 450 /// deallocated using an explicit destructor call followed by 451 /// @c Context.Deallocate(Ptr). 452 /// 453 /// @param Bytes The number of bytes to allocate. Calculated by the compiler. 454 /// @param C The MCContext that provides the allocator. 455 /// @param Alignment The alignment of the allocated memory (if the underlying 456 /// allocator supports it). 457 /// @return The allocated memory. Could be NULL. 458 inline void *operator new(size_t Bytes, llvm::MCContext &C, 459 size_t Alignment = 16) throw () { 460 return C.Allocate(Bytes, Alignment); 461 } 462 /// @brief Placement delete companion to the new above. 463 /// 464 /// This operator is just a companion to the new above. There is no way of 465 /// invoking it directly; see the new operator for more details. This operator 466 /// is called implicitly by the compiler if a placement new expression using 467 /// the MCContext throws in the object constructor. 468 inline void operator delete(void *Ptr, llvm::MCContext &C, size_t) 469 throw () { 470 C.Deallocate(Ptr); 471 } 472 473 /// This placement form of operator new[] uses the MCContext's allocator for 474 /// obtaining memory. It is a non-throwing new[], which means that it returns 475 /// null on error. 476 /// Usage looks like this (assuming there's an MCContext 'Context' in scope): 477 /// @code 478 /// // Default alignment (16) 479 /// char *data = new (Context) char[10]; 480 /// // Specific alignment 481 /// char *data = new (Context, 8) char[10]; 482 /// @endcode 483 /// Please note that you cannot use delete on the pointer; it must be 484 /// deallocated using an explicit destructor call followed by 485 /// @c Context.Deallocate(Ptr). 486 /// 487 /// @param Bytes The number of bytes to allocate. Calculated by the compiler. 488 /// @param C The MCContext that provides the allocator. 489 /// @param Alignment The alignment of the allocated memory (if the underlying 490 /// allocator supports it). 491 /// @return The allocated memory. Could be NULL. 492 inline void *operator new[](size_t Bytes, llvm::MCContext& C, 493 size_t Alignment = 16) throw () { 494 return C.Allocate(Bytes, Alignment); 495 } 496 497 /// @brief Placement delete[] companion to the new[] above. 498 /// 499 /// This operator is just a companion to the new[] above. There is no way of 500 /// invoking it directly; see the new[] operator for more details. This operator 501 /// is called implicitly by the compiler if a placement new[] expression using 502 /// the MCContext throws in the object constructor. 503 inline void operator delete[](void *Ptr, llvm::MCContext &C) throw () { 504 C.Deallocate(Ptr); 505 } 506 507 #endif 508
