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
28namespace 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.
458inline 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.
468inline 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.
492inline 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.
503inline void operator delete[](void *Ptr, llvm::MCContext &C) throw () {
504  C.Deallocate(Ptr);
505}
506
507#endif
508