1 files changed, 128 insertions, 5 deletions

diff --git a/include/llvm/MC/MCContext.h b/include/llvm/MC/MCContext.h
index 3c2addf..f5e75eb 100644
--- a/include/llvm/MC/MCContext.h
+++ b/include/llvm/MC/MCContext.h
@@ -10,6 +10,10 @@
 #ifndef LLVM_MC_MCCONTEXT_H
 #define LLVM_MC_MCCONTEXT_H
 
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/Support/Allocator.h"
+
 namespace llvm {
   class MCAtom;
   class MCImm;
@@ -21,21 +25,140 @@ namespace llvm {
     MCContext(const MCContext&); // DO NOT IMPLEMENT
     MCContext &operator=(const MCContext&); // DO NOT IMPLEMENT
 
+    /// Sections - Bindings of names to allocated sections.
+    StringMap<MCSection*> Sections;
+
+    /// Symbols - Bindings of names to symbols.
+    StringMap<MCSymbol*> Symbols;
+
+    /// SymbolValues - Bindings of symbols to values.
+    DenseMap<MCSymbol*, MCImm> SymbolValues;
+
+    /// Allocator - Allocator object used for creating machine code objects.
+    ///
+    /// We use a bump pointer allocator to avoid the need to track all allocated
+    /// objects.
+    BumpPtrAllocator Allocator;
+
   public:
     MCContext();
     ~MCContext();
 
+    /// GetSection - Get or create a new section with the given @param Name.
     MCSection *GetSection(const char *Name);
+    
+    /// CreateAtom - Create a new atom inside @param Section.
     MCAtom *CreateAtom(MCSection *Section);
-    MCSymbol *CreateSymbol(MCAtom *Atom,
-                           const char *Name,
-                           bool IsTemporary);
+
+    /// CreateSymbol - Create a new symbol inside @param Atom with the specified
+    /// @param Name.
+    ///
+    /// @param Name - The symbol name, which must be unique across all symbols.
+    MCSymbol *CreateSymbol(MCAtom *Atom, const char *Name);
+
+    /// CreateTemporarySymbol - Create a new temporary symbol inside @param Atom
+    /// with the specified @param Name.
+    ///
+    /// @param Name - The symbol name, for debugging purposes only, temporary
+    /// symbols do not surive assembly. If non-empty the name must be unique
+    /// across all symbols.
+    MCSymbol *CreateTemporarySymbol(MCAtom *Atom, const char *Name = "");
+
+    /// LookupSymbol - Get the symbol for @param Name, or null.
     MCSymbol *LookupSymbol(const char *Name) const;
 
-    void SetSymbolValue(MCSymbol *Sym, const MCImm &Value);
-    const MCImm &GetSymbolValue(MCSymbol *Sym) const;
+    /// ClearSymbolValue - Erase a value binding for @param Symbol, if one
+    /// exists.
+    void ClearSymbolValue(MCSymbol *Symbol);
+
+    /// SetSymbolValue - Set the value binding for @param Symbol to @param
+    /// Value.
+    void SetSymbolValue(MCSymbol *Symbol, const MCImm &Value);
+
+    /// GetSymbolValue - Return the current value for @param Symbol, or null if
+    /// none exists.
+    const MCImm *GetSymbolValue(MCSymbol *Symbol) const;
+
+    void *Allocate(unsigned Size, unsigned Align = 8) {
+      return Allocator.Allocate(Size, Align);
+    }
+    void Deallocate(void *Ptr) { 
+    }
   };
 
 } // end namespace llvm
 
+// operator new and delete aren't allowed inside namespaces.
+// The throw specifications are mandated by the standard.
+/// @brief Placement new for using the MCContext's allocator.
+///
+/// This placement form of operator new uses the MCContext's allocator for
+/// obtaining memory. It is a non-throwing new, which means that it returns
+/// null on error. (If that is what the allocator does. The current does, so if
+/// this ever changes, this operator will have to be changed, too.)
+/// Usage looks like this (assuming there's an MCContext 'Context' in scope):
+/// @code
+/// // Default alignment (16)
+/// IntegerLiteral *Ex = new (Context) IntegerLiteral(arguments);
+/// // Specific alignment
+/// IntegerLiteral *Ex2 = new (Context, 8) IntegerLiteral(arguments);
+/// @endcode
+/// Please note that you cannot use delete on the pointer; it must be
+/// deallocated using an explicit destructor call followed by
+/// @c Context.Deallocate(Ptr).
+///
+/// @param Bytes The number of bytes to allocate. Calculated by the compiler.
+/// @param C The MCContext that provides the allocator.
+/// @param Alignment The alignment of the allocated memory (if the underlying
+///                  allocator supports it).
+/// @return The allocated memory. Could be NULL.
+inline void *operator new(size_t Bytes, llvm::MCContext &C,
+                          size_t Alignment) throw () {
+  return C.Allocate(Bytes, Alignment);
+}
+/// @brief Placement delete companion to the new above.
+///
+/// This operator is just a companion to the new above. There is no way of
+/// invoking it directly; see the new operator for more details. This operator
+/// is called implicitly by the compiler if a placement new expression using
+/// the MCContext throws in the object constructor.
+inline void operator delete(void *Ptr, llvm::MCContext &C, size_t)
+              throw () {
+  C.Deallocate(Ptr);
+}
+
+/// This placement form of operator new[] uses the MCContext's allocator for
+/// obtaining memory. It is a non-throwing new[], which means that it returns
+/// null on error.
+/// Usage looks like this (assuming there's an MCContext 'Context' in scope):
+/// @code
+/// // Default alignment (16)
+/// char *data = new (Context) char[10];
+/// // Specific alignment
+/// char *data = new (Context, 8) char[10];
+/// @endcode
+/// Please note that you cannot use delete on the pointer; it must be
+/// deallocated using an explicit destructor call followed by
+/// @c Context.Deallocate(Ptr).
+///
+/// @param Bytes The number of bytes to allocate. Calculated by the compiler.
+/// @param C The MCContext that provides the allocator.
+/// @param Alignment The alignment of the allocated memory (if the underlying
+///                  allocator supports it).
+/// @return The allocated memory. Could be NULL.
+inline void *operator new[](size_t Bytes, llvm::MCContext& C,
+                            size_t Alignment = 16) throw () {
+  return C.Allocate(Bytes, Alignment);
+}
+
+/// @brief Placement delete[] companion to the new[] above.
+///
+/// This operator is just a companion to the new[] above. There is no way of
+/// invoking it directly; see the new[] operator for more details. This operator
+/// is called implicitly by the compiler if a placement new[] expression using
+/// the MCContext throws in the object constructor.
+inline void operator delete[](void *Ptr, llvm::MCContext &C) throw () {
+  C.Deallocate(Ptr);
+}
+
 #endif