Start flushing out MCContext.

- Lives inside new library lib/MC (LLVMMC.a)


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@74013 91177308-0d34-0410-b5e6-96231b3b80d8

CMakeLists.txt

@@ -236,6 +236,7 @@ add_subdirectory(lib/Transforms/Hello)
 add_subdirectory(lib/Linker)
 add_subdirectory(lib/Analysis)
 add_subdirectory(lib/Analysis/IPA)
+add_subdirectory(lib/MC)
 
  set(LLVM_ENUM_ASM_PRINTERS "")
  foreach(t ${LLVM_TARGETS_TO_BUILD})

include/llvm/MC/MCAtom.h

@@ -0,0 +1,24 @@
+//===- MCAtom.h - Machine Code Atoms ----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCATOM_H
+#define LLVM_MC_MCATOM_H
+
+namespace llvm {
+
+  class MCAtom {
+    MCSection *Section;
+
+  public:
+    MCAtom(MCSection *_Section) : Section(_Section) {}
+  };
+
+} // end namespace llvm
+
+#endif

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

include/llvm/MC/MCSection.h

@@ -0,0 +1,26 @@
+//===- MCSection.h - Machine Code Sections ----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCSECTION_H
+#define LLVM_MC_MCSECTION_H
+
+#include <string>
+
+namespace llvm {
+
+  class MCSection {
+    std::string Name;
+
+  public:
+    MCSection(const char *_Name) : Name(_Name) {}
+  };
+
+} // end namespace llvm
+
+#endif

include/llvm/MC/MCSymbol.h

@@ -0,0 +1,30 @@
+//===- MCSymbol.h - Machine Code Symbols ------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCSYMBOL_H
+#define LLVM_MC_MCSYMBOL_H
+
+#include <string>
+
+namespace llvm {
+  class MCAtom;
+
+  class MCSymbol {
+    MCAtom *Atom;
+    std::string Name;
+    unsigned IsTemporary : 1;
+
+  public:
+    MCSymbol(MCAtom *_Atom, const char *_Name, bool _IsTemporary) 
+      : Atom(_Atom), Name(_Name), IsTemporary(_IsTemporary) {}
+  };
+
+} // end namespace llvm
+
+#endif

lib/MC/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_llvm_library(LLVMMC
+  MCContext.cpp
+  )

lib/MC/MCContext.cpp

@@ -0,0 +1,77 @@
+//===- 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;
+}

lib/MC/Makefile

@@ -0,0 +1,15 @@
+##===- lib/MC/Makefile -------------------------------------*- Makefile -*-===##
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+
+LEVEL = ../..
+LIBRARYNAME = LLVMMC
+BUILD_ARCHIVE := 1
+
+include $(LEVEL)/Makefile.common
+

lib/Makefile

@@ -9,7 +9,7 @@
 LEVEL = ..
 
 PARALLEL_DIRS = VMCore AsmParser Bitcode Archive Analysis Transforms CodeGen \
-                Target ExecutionEngine Debugger Linker CompilerDriver
+                Target ExecutionEngine Debugger Linker CompilerDriver MC
 
 include $(LEVEL)/Makefile.common
 

tools/llvm-mc/AsmParser.cpp

@@ -12,7 +12,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "AsmParser.h"
+#include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInst.h"
+#include "llvm/MC/MCStreamer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;