RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-12-03 08:51:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Implementation of SlotTable went into header file. Note that this header

Browse Source 
is currently not being used but is retained because it will be the basis
for a clean up of the SlotCalculator class.

llvm-svn: 14612
This commit is contained in:
Reid Spencer 2004-07-04 11:47:22 +00:00
parent 3c5a47177e
commit 373ae97a58
1 changed files with 0 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
lib/Bytecode/Writer/SlotTable.cpp
View File

@ -1,116 +0,0 @@
//===-- SlotTable.cpp - Abstract data type for slot numbers ---------------===//
//
// 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 an abstract data type for keeping track of slot numbers
// for bytecode and assembly writing or any other purpose.
//
//===----------------------------------------------------------------------===//
#include "SlotTable.h"
#include "llvm/Constants.h"
#include "llvm/Type.h"
#include "llvm/GlobalValue.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
SlotTable::SlotNum SlotTable::insert( const Type* Typ ) {
// Insert node into table and map making sure that
// the same type isn't inserted twice.
assert(tMap.find(Typ) == tMap.end() && "Can't insert a Type multiple times");
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::TypeID) 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