Adding the initial implementation of the SlotTable class. This class is

the Abstract Data Type that holds slot number values and associates them
with Type* and Value*. The SlotTable is simply the holder of the slot
numbers and provides a controlled interface for building the table. It does
not enforce any particular idiom or functionality for manipulating the slot
numbers.

This is part of bug_122. The SlotCalculator and SlotMachine classes will
follow.


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

lib/Bytecode/Writer/SlotTable.cpp

@@ -0,0 +1,115 @@
+//===-- SlotCalculator.cpp - Calculate what slots values land in ----------===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
+//
+// This file implements a utility class for keeping track of slot numbers for
+// bytecode and assembly writing.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Internal/SlotTable.h"
+#include "llvm/Type.h"
+#include "llvm/Value.h"
+#include "llvm/GlobalValue.h"
+#include "llvm/Constants.h"
+
+using namespace llvm;
+
+//===----------------------------------------------------------------------===//
+//                            SlotTable Implementation
+//===----------------------------------------------------------------------===//
+
+SlotTable::SlotTable( bool dont_insert_primitives ) {
+  if ( ! dont_insert_primitives ) 
+    this->insertPrimitives();
+}
+
+// empty - determine if the slot table is completely empty.
+bool SlotTable::empty() const {
+  return vTable.empty() && vMap.empty() && tPlane.empty() && tMap.empty();
+}
+
+// getSlot - get the slot number associated with value Val
+SlotTable::SlotNum SlotTable::getSlot(const Value* Val) const {
+  ValueMap::const_iterator I = vMap.find( Val );
+  if ( I != vMap.end() )
+    return I->second;
+
+  // Do not number ConstantPointerRef's at all.  They are an abomination.
+  if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(Val))
+    return this->getSlot(CPR->getValue());
+
+  return BAD_SLOT;
+}
+
+// getSlot - get the slot number associated with type Typ
+SlotTable::SlotNum SlotTable::getSlot(const Type* Typ) const {
+  TypeMap::const_iterator I = tMap.find( Typ );
+  if ( I != tMap.end() )
+    return I->second;
+
+  return BAD_SLOT;
+}
+
+// clear - completely clear the slot table of all entries
+void SlotTable::clear() {
+  vTable.clear();
+  vMap.clear();
+  tPlane.clear();
+  tMap.clear();
+}
+
+// resize - make sure there's enough room for specific number of planes
+void SlotTable::resize( size_t new_size ) {
+  vTable.resize( new_size );
+}
+
+// insert - insert a Value into a specific plane
+SlotTable::SlotNum SlotTable::insert( const Value* Val, PlaneNum plane ) {
+  if ( vTable.size() <= plane ) // Make sure we have the type plane allocated
+    vTable.resize(plane+1, ValuePlane());
+
+  // Insert node into table and map
+  SlotNum DestSlot = vMap[Val] = vTable[plane].size();
+  vTable[plane].push_back(Val);
+  return DestSlot;
+}
+
+// insert - insert a type into a specific plane
+SlotTable::SlotNum SlotTable::insert( const Type* Typ ) {
+  // Insert node into table and map
+  SlotNum DestSlot = tMap[Typ] = tPlane.size();
+  tPlane.push_back(Typ);
+  return DestSlot;
+}
+
+// remove - remove a value from the slot table
+SlotTable::SlotNum SlotTable::remove( const Value* Val, PlaneNum plane ) {
+  // FIXME: not implemented - not sure we need it
+  return BAD_SLOT;
+}
+
+// remove - remove a type from the slot table
+SlotTable::SlotNum SlotTable::remove( const Type* Typ ) {
+  // FIXME: not implemented - not sure we need it
+  return BAD_SLOT;
+}
+
+// insertPrimitives - insert the primitive types for initialization
+// Make sure that all of the primitive types are in the table
+// and that their Primitive ID is equal to their slot #
+void SlotTable::insertPrimitives() {
+  for (PlaneNum plane = 0; plane < Type::FirstDerivedTyID; ++plane) {
+    const Type* Ty = Type::getPrimitiveType((Type::PrimitiveID) plane);
+    assert(Ty && "Couldn't get primitive type id");
+    SlotNum slot = this->insert(Ty);
+    assert(slot == plane && "Type slot didn't match plane number");
+  }
+}
+
+// vim: sw=2