MCContext.h revision 7c3600de949347bf5ea6369b2546fac15bd96415 
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/StringMap.h"
15#include "llvm/Support/Allocator.h"
16
17namespace llvm {
18  class MCExpr;
19  class MCSection;
20  class MCSymbol;
21  class StringRef;
22
23  /// MCContext - Context object for machine code objects.  This class owns all
24  /// of the sections that it creates.
25  ///
26  class MCContext {
27    MCContext(const MCContext&); // DO NOT IMPLEMENT
28    MCContext &operator=(const MCContext&); // DO NOT IMPLEMENT
29
30    /// Sections - Bindings of names to allocated sections.
31    StringMap<MCSection*> Sections;
32
33    /// Symbols - Bindings of names to symbols.
34    StringMap<MCSymbol*> Symbols;
35
36    /// Allocator - Allocator object used for creating machine code objects.
37    ///
38    /// We use a bump pointer allocator to avoid the need to track all allocated
39    /// objects.
40    BumpPtrAllocator Allocator;
41  public:
42    MCContext();
43    ~MCContext();
44
45    /// @name Symbol Managment
46    /// @{
47
48    /// CreateSymbol - Create a new symbol with the specified @param Name.
49    ///
50    /// @param Name - The symbol name, which must be unique across all symbols.
51    MCSymbol *CreateSymbol(const StringRef &Name);
52
53    /// GetOrCreateSymbol - Lookup the symbol inside with the specified
54    /// @param Name.  If it exists, return it.  If not, create a forward
55    /// reference and return it.
56    ///
57    /// @param Name - The symbol name, which must be unique across all symbols.
58    /// @param IsTemporary - Whether this symbol is an assembler temporary,
59    /// which should not survive into the symbol table for the translation unit.
60    MCSymbol *GetOrCreateSymbol(const StringRef &Name);
61
62    /// CreateTemporarySymbol - Create a new temporary symbol with the specified
63    /// @param Name.
64    ///
65    /// @param Name - The symbol name, for debugging purposes only, temporary
66    /// symbols do not surive assembly. If non-empty the name must be unique
67    /// across all symbols.
68    MCSymbol *CreateTemporarySymbol(const StringRef &Name = "");
69
70    /// LookupSymbol - Get the symbol for @param Name, or null.
71    MCSymbol *LookupSymbol(const StringRef &Name) const;
72
73    /// @}
74
75    void *Allocate(unsigned Size, unsigned Align = 8) {
76      return Allocator.Allocate(Size, Align);
77    }
78    void Deallocate(void *Ptr) {
79    }
80  };
81
82} // end namespace llvm
83
84// operator new and delete aren't allowed inside namespaces.
85// The throw specifications are mandated by the standard.
86/// @brief Placement new for using the MCContext's allocator.
87///
88/// This placement form of operator new uses the MCContext's allocator for
89/// obtaining memory. It is a non-throwing new, which means that it returns
90/// null on error. (If that is what the allocator does. The current does, so if
91/// this ever changes, this operator will have to be changed, too.)
92/// Usage looks like this (assuming there's an MCContext 'Context' in scope):
93/// @code
94/// // Default alignment (16)
95/// IntegerLiteral *Ex = new (Context) IntegerLiteral(arguments);
96/// // Specific alignment
97/// IntegerLiteral *Ex2 = new (Context, 8) IntegerLiteral(arguments);
98/// @endcode
99/// Please note that you cannot use delete on the pointer; it must be
100/// deallocated using an explicit destructor call followed by
101/// @c Context.Deallocate(Ptr).
102///
103/// @param Bytes The number of bytes to allocate. Calculated by the compiler.
104/// @param C The MCContext that provides the allocator.
105/// @param Alignment The alignment of the allocated memory (if the underlying
106///                  allocator supports it).
107/// @return The allocated memory. Could be NULL.
108inline void *operator new(size_t Bytes, llvm::MCContext &C,
109                          size_t Alignment = 16) throw () {
110  return C.Allocate(Bytes, Alignment);
111}
112/// @brief Placement delete companion to the new above.
113///
114/// This operator is just a companion to the new above. There is no way of
115/// invoking it directly; see the new operator for more details. This operator
116/// is called implicitly by the compiler if a placement new expression using
117/// the MCContext throws in the object constructor.
118inline void operator delete(void *Ptr, llvm::MCContext &C, size_t)
119              throw () {
120  C.Deallocate(Ptr);
121}
122
123/// This placement form of operator new[] uses the MCContext's allocator for
124/// obtaining memory. It is a non-throwing new[], which means that it returns
125/// null on error.
126/// Usage looks like this (assuming there's an MCContext 'Context' in scope):
127/// @code
128/// // Default alignment (16)
129/// char *data = new (Context) char[10];
130/// // Specific alignment
131/// char *data = new (Context, 8) char[10];
132/// @endcode
133/// Please note that you cannot use delete on the pointer; it must be
134/// deallocated using an explicit destructor call followed by
135/// @c Context.Deallocate(Ptr).
136///
137/// @param Bytes The number of bytes to allocate. Calculated by the compiler.
138/// @param C The MCContext that provides the allocator.
139/// @param Alignment The alignment of the allocated memory (if the underlying
140///                  allocator supports it).
141/// @return The allocated memory. Could be NULL.
142inline void *operator new[](size_t Bytes, llvm::MCContext& C,
143                            size_t Alignment = 16) throw () {
144  return C.Allocate(Bytes, Alignment);
145}
146
147/// @brief Placement delete[] companion to the new[] above.
148///
149/// This operator is just a companion to the new[] above. There is no way of
150/// invoking it directly; see the new[] operator for more details. This operator
151/// is called implicitly by the compiler if a placement new[] expression using
152/// the MCContext throws in the object constructor.
153inline void operator delete[](void *Ptr, llvm::MCContext &C) throw () {
154  C.Deallocate(Ptr);
155}
156
157#endif
158