1
//===- MCContext.h - Machine Code Context -----------------------*- C++ -*-===//
3
// The LLVM Compiler Infrastructure
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
8
//===----------------------------------------------------------------------===//
10
#ifndef LLVM_MC_MCCONTEXT_H
11
#define LLVM_MC_MCCONTEXT_H
13
#include "llvm/ADT/DenseMap.h"
14
#include "llvm/ADT/StringMap.h"
15
#include "llvm/Support/Allocator.h"
24
/// MCContext - Context object for machine code objects. This class owns all
25
/// of the sections that it creates.
28
MCContext(const MCContext&); // DO NOT IMPLEMENT
29
MCContext &operator=(const MCContext&); // DO NOT IMPLEMENT
31
/// Sections - Bindings of names to allocated sections.
32
StringMap<MCSection*> Sections;
34
/// Symbols - Bindings of names to symbols.
35
StringMap<MCSymbol*> Symbols;
37
/// Allocator - Allocator object used for creating machine code objects.
39
/// We use a bump pointer allocator to avoid the need to track all allocated
41
BumpPtrAllocator Allocator;
46
/// @name Symbol Managment
49
/// CreateSymbol - Create a new symbol with the specified @p Name.
51
/// @param Name - The symbol name, which must be unique across all symbols.
52
MCSymbol *CreateSymbol(StringRef Name);
54
/// GetOrCreateSymbol - Lookup the symbol inside with the specified
55
/// @p Name. If it exists, return it. If not, create a forward
56
/// reference and return it.
58
/// @param Name - The symbol name, which must be unique across all symbols.
59
MCSymbol *GetOrCreateSymbol(StringRef Name);
60
MCSymbol *GetOrCreateSymbol(const Twine &Name);
62
/// CreateTemporarySymbol - Create a new temporary symbol with the specified
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(StringRef Name = "");
70
/// LookupSymbol - Get the symbol for \p Name, or null.
71
MCSymbol *LookupSymbol(StringRef Name) const;
75
void *Allocate(unsigned Size, unsigned Align = 8) {
76
return Allocator.Allocate(Size, Align);
78
void Deallocate(void *Ptr) {
82
} // end namespace llvm
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.
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):
94
/// // Default alignment (16)
95
/// IntegerLiteral *Ex = new (Context) IntegerLiteral(arguments);
96
/// // Specific alignment
97
/// IntegerLiteral *Ex2 = new (Context, 8) IntegerLiteral(arguments);
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).
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.
108
inline void *operator new(size_t Bytes, llvm::MCContext &C,
109
size_t Alignment = 16) throw () {
110
return C.Allocate(Bytes, Alignment);
112
/// @brief Placement delete companion to the new above.
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.
118
inline void operator delete(void *Ptr, llvm::MCContext &C, size_t)
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
126
/// Usage looks like this (assuming there's an MCContext 'Context' in scope):
128
/// // Default alignment (16)
129
/// char *data = new (Context) char[10];
130
/// // Specific alignment
131
/// char *data = new (Context, 8) char[10];
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).
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.
142
inline void *operator new[](size_t Bytes, llvm::MCContext& C,
143
size_t Alignment = 16) throw () {
144
return C.Allocate(Bytes, Alignment);
147
/// @brief Placement delete[] companion to the new[] above.
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.
153
inline void operator delete[](void *Ptr, llvm::MCContext &C) throw () {