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