[llvm-commits] CVS: llvm/lib/Support/SlotTable.cpp

[LLVM]

Changes in directory llvm/lib/Support:

SlotTable.cpp added (r1.1)

---
Log message:

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.


---
Diffs of the changes:  (+115 -0)

Index: llvm/lib/Support/SlotTable.cpp
diff -c /dev/null llvm/lib/Support/SlotTable.cpp:1.1
*** /dev/null	Tue May 25 13:45:01 2004
--- llvm/lib/Support/SlotTable.cpp	Tue May 25 13:44:51 2004
***************
*** 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