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