#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;
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
--- /dev/null
+//===- lib/MachineCode/MCContext.cpp - Machine Code Context ---------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/MC/MCContext.h"
+
+#include "llvm/MC/MCAtom.h"
+#include "llvm/MC/MCImm.h"
+#include "llvm/MC/MCSection.h"
+#include "llvm/MC/MCSymbol.h"
+using namespace llvm;
+
+MCContext::MCContext()
+{
+}
+
+MCContext::~MCContext() {
+}
+
+MCSection *MCContext::GetSection(const char *Name) {
+ MCSection *&Entry = Sections[Name];
+
+ if (!Entry)
+ Entry = new (this) MCSection(Name);
+
+ return Entry;
+}
+
+MCAtom *MCContext::CreateAtom(MCSection *Section) {
+ return new (this) MCAtom(Section);
+}
+
+MCSymbol *MCContext::CreateSymbol(MCAtom *Atom, const char *Name) {
+ assert(Name[0] != '\0' && "Normal symbols cannot be unnamed!");
+
+ // Create and bind the symbol, and ensure that names are unique.
+ MCSymbol *&Entry = Symbols[Name];
+ assert(!Entry && "Duplicate symbol definition!");
+ return Entry = new (this) MCSymbol(Atom, Name, false);
+}
+
+MCSymbol *MCContext::CreateTemporarySymbol(MCAtom *Atom, const char *Name) {
+ // If unnamed, just create a symbol.
+ if (Name[0] == '\0')
+ new (this) MCSymbol(Atom, "", true);
+
+ // Otherwise create as usual.
+ MCSymbol *&Entry = Symbols[Name];
+ assert(!Entry && "Duplicate symbol definition!");
+ return Entry = new (this) MCSymbol(Atom, Name, true);
+}
+
+MCSymbol *MCContext::LookupSymbol(const char *Name) const {
+ return Symbols.lookup(Name);
+}
+
+void MCContext::ClearSymbolValue(MCSymbol *Sym) {
+ SymbolValues.erase(Sym);
+}
+
+void MCContext::SetSymbolValue(MCSymbol *Sym, const MCImm &Value) {
+ SymbolValues[Sym] = Value;
+}
+
+const MCImm *MCContext::GetSymbolValue(MCSymbol *Sym) const {
+ DenseMap<MCSymbol*, MCImm>::iterator it = SymbolValues.find(Sym);
+
+ if (it == SymbolValues.end())
+ return 0;
+
+ return &it->second;
+}