2004-01-20 19:50:12 +00:00
|
|
|
//===-- Analysis/SlotCalculator.h - Calculate value slots -------*- C++ -*-===//
|
2005-04-21 21:48:46 +00:00
|
|
|
//
|
2003-10-20 20:19:47 +00:00
|
|
|
// 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.
|
2005-04-21 21:48:46 +00:00
|
|
|
//
|
2003-10-20 20:19:47 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2002-04-07 22:49:37 +00:00
|
|
|
// This class calculates the slots that values will land in. This is useful for
|
|
|
|
// when writing bytecode or assembly out, because you have to know these things.
|
|
|
|
//
|
|
|
|
// Specifically, this class calculates the "type plane numbering" that you see
|
|
|
|
// for a function if you strip out all of the symbols in it. For assembly
|
|
|
|
// writing, this is used when a symbol does not have a name. For bytecode
|
|
|
|
// writing, this is always used, and the symbol table is added on later.
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2004-01-20 19:50:12 +00:00
|
|
|
#ifndef LLVM_ANALYSIS_SLOTCALCULATOR_H
|
|
|
|
#define LLVM_ANALYSIS_SLOTCALCULATOR_H
|
2001-06-06 20:29:01 +00:00
|
|
|
|
|
|
|
#include <vector>
|
|
|
|
#include <map>
|
2003-11-11 22:41:34 +00:00
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
|
2001-07-14 06:08:51 +00:00
|
|
|
class Value;
|
2004-07-04 11:42:49 +00:00
|
|
|
class Type;
|
2001-09-07 16:27:05 +00:00
|
|
|
class Module;
|
2002-03-23 22:51:58 +00:00
|
|
|
class Function;
|
2002-04-09 18:35:38 +00:00
|
|
|
class SymbolTable;
|
2007-01-06 07:24:44 +00:00
|
|
|
class TypeSymbolTable;
|
2004-01-14 23:37:43 +00:00
|
|
|
class ConstantArray;
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2001-09-07 16:27:05 +00:00
|
|
|
class SlotCalculator {
|
2001-06-06 20:29:01 +00:00
|
|
|
const Module *TheModule;
|
2004-01-14 02:49:34 +00:00
|
|
|
|
2004-07-04 11:42:49 +00:00
|
|
|
typedef std::vector<const Type*> TypeList;
|
2002-01-20 22:54:45 +00:00
|
|
|
typedef std::vector<const Value*> TypePlane;
|
|
|
|
std::vector<TypePlane> Table;
|
2004-07-04 11:42:49 +00:00
|
|
|
TypeList Types;
|
|
|
|
typedef std::map<const Value*, unsigned> NodeMapType;
|
|
|
|
NodeMapType NodeMap;
|
|
|
|
|
|
|
|
typedef std::map<const Type*, unsigned> TypeMapType;
|
|
|
|
TypeMapType TypeMap;
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2004-01-14 23:37:43 +00:00
|
|
|
/// ConstantStrings - If we are indexing for a bytecode file, this keeps track
|
|
|
|
/// of all of the constants strings that need to be emitted.
|
|
|
|
std::vector<const ConstantArray*> ConstantStrings;
|
|
|
|
|
|
|
|
/// ModuleLevel - Used to keep track of which values belong to the module,
|
|
|
|
/// and which values belong to the currently incorporated function.
|
|
|
|
///
|
2002-01-20 22:54:45 +00:00
|
|
|
std::vector<unsigned> ModuleLevel;
|
2004-07-04 11:42:49 +00:00
|
|
|
unsigned ModuleTypeLevel;
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2004-01-18 21:03:49 +00:00
|
|
|
/// ModuleContainsAllFunctionConstants - This flag is set to true if all
|
|
|
|
/// function constants are incorporated into the module constant table. This
|
|
|
|
/// is only possible if building information for a bytecode file.
|
|
|
|
bool ModuleContainsAllFunctionConstants;
|
|
|
|
|
|
|
|
/// CompactionTable/NodeMap - When function compaction has been performed,
|
|
|
|
/// these entries provide a compacted view of the namespace needed to emit
|
|
|
|
/// instructions in a function body. The 'getSlot()' method automatically
|
|
|
|
/// returns these entries if applicable, or the global entries if not.
|
|
|
|
std::vector<TypePlane> CompactionTable;
|
2004-07-04 11:42:49 +00:00
|
|
|
TypeList CompactionTypes;
|
|
|
|
typedef std::map<const Value*, unsigned> CompactionNodeMapType;
|
|
|
|
CompactionNodeMapType CompactionNodeMap;
|
|
|
|
typedef std::map<const Type*, unsigned> CompactionTypeMapType;
|
|
|
|
CompactionTypeMapType CompactionTypeMap;
|
2004-01-18 21:03:49 +00:00
|
|
|
|
|
|
|
SlotCalculator(const SlotCalculator &); // DO NOT IMPLEMENT
|
|
|
|
void operator=(const SlotCalculator &); // DO NOT IMPLEMENT
|
2001-06-06 20:29:01 +00:00
|
|
|
public:
|
2006-01-25 23:08:15 +00:00
|
|
|
SlotCalculator(const Module *M);
|
2002-03-23 22:51:58 +00:00
|
|
|
// Start out in incorp state
|
2006-01-25 23:08:15 +00:00
|
|
|
SlotCalculator(const Function *F);
|
2005-04-21 21:48:46 +00:00
|
|
|
|
2004-01-18 21:03:49 +00:00
|
|
|
/// getSlot - Return the slot number of the specified value in it's type
|
|
|
|
/// plane. This returns < 0 on error!
|
2004-01-14 23:37:43 +00:00
|
|
|
///
|
2004-01-18 21:03:49 +00:00
|
|
|
int getSlot(const Value *V) const;
|
2004-07-04 11:42:49 +00:00
|
|
|
int getSlot(const Type* T) const;
|
2004-01-18 21:03:49 +00:00
|
|
|
|
|
|
|
/// getGlobalSlot - Return a slot number from the global table. This can only
|
|
|
|
/// be used when a compaction table is active.
|
|
|
|
unsigned getGlobalSlot(const Value *V) const;
|
2004-07-04 11:42:49 +00:00
|
|
|
unsigned getGlobalSlot(const Type *V) const;
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2004-01-18 21:03:49 +00:00
|
|
|
inline unsigned getNumPlanes() const {
|
|
|
|
if (CompactionTable.empty())
|
|
|
|
return Table.size();
|
|
|
|
else
|
|
|
|
return CompactionTable.size();
|
|
|
|
}
|
2004-07-04 11:42:49 +00:00
|
|
|
|
|
|
|
inline unsigned getNumTypes() const {
|
|
|
|
if (CompactionTypes.empty())
|
|
|
|
return Types.size();
|
|
|
|
else
|
|
|
|
return CompactionTypes.size();
|
|
|
|
}
|
|
|
|
|
2005-04-21 21:48:46 +00:00
|
|
|
inline unsigned getModuleLevel(unsigned Plane) const {
|
|
|
|
return Plane < ModuleLevel.size() ? ModuleLevel[Plane] : 0;
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2004-07-04 11:42:49 +00:00
|
|
|
/// Returns the number of types in the type list that are at module level
|
|
|
|
inline unsigned getModuleTypeLevel() const {
|
|
|
|
return ModuleTypeLevel;
|
|
|
|
}
|
|
|
|
|
2004-01-20 00:54:47 +00:00
|
|
|
TypePlane &getPlane(unsigned Plane);
|
2005-04-21 21:48:46 +00:00
|
|
|
TypeList& getTypes() {
|
2004-07-04 11:42:49 +00:00
|
|
|
if (!CompactionTypes.empty())
|
|
|
|
return CompactionTypes;
|
|
|
|
return Types;
|
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2004-01-14 23:37:43 +00:00
|
|
|
/// incorporateFunction/purgeFunction - If you'd like to deal with a function,
|
|
|
|
/// use these two methods to get its data into the SlotCalculator!
|
|
|
|
///
|
2002-04-07 22:49:37 +00:00
|
|
|
void incorporateFunction(const Function *F);
|
|
|
|
void purgeFunction();
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2004-01-14 23:37:43 +00:00
|
|
|
/// string_iterator/string_begin/end - Access the list of module-level
|
|
|
|
/// constant strings that have been incorporated. This is only applicable to
|
|
|
|
/// bytecode files.
|
|
|
|
typedef std::vector<const ConstantArray*>::const_iterator string_iterator;
|
|
|
|
string_iterator string_begin() const { return ConstantStrings.begin(); }
|
|
|
|
string_iterator string_end() const { return ConstantStrings.end(); }
|
|
|
|
|
2004-01-18 21:03:49 +00:00
|
|
|
const std::vector<TypePlane> &getCompactionTable() const {
|
|
|
|
return CompactionTable;
|
|
|
|
}
|
2004-01-14 23:37:43 +00:00
|
|
|
|
2004-07-04 11:42:49 +00:00
|
|
|
const TypeList& getCompactionTypes() const { return CompactionTypes; }
|
|
|
|
|
2004-08-26 22:32:00 +00:00
|
|
|
/// @brief Determine if the compaction table (not types) is empty
|
|
|
|
bool CompactionTableIsEmpty() const;
|
|
|
|
|
2004-01-18 21:03:49 +00:00
|
|
|
private:
|
2003-10-17 02:02:40 +00:00
|
|
|
// getOrCreateSlot - Values can be crammed into here at will... if
|
|
|
|
// they haven't been inserted already, they get inserted, otherwise
|
|
|
|
// they are ignored.
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2006-01-25 23:08:15 +00:00
|
|
|
int getOrCreateSlot(const Value *V);
|
|
|
|
int getOrCreateSlot(const Type *T);
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2003-10-17 02:02:40 +00:00
|
|
|
// insertValue - Insert a value into the value table... Return the
|
|
|
|
// slot that it occupies, or -1 if the declaration is to be ignored
|
|
|
|
// because of the IgnoreNamedNodes flag.
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2003-10-17 02:02:40 +00:00
|
|
|
int insertValue(const Value *D, bool dontIgnore = false);
|
2006-01-25 23:08:15 +00:00
|
|
|
int insertType(const Type *T, bool dontIgnore = false);
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2003-10-17 02:02:40 +00:00
|
|
|
// doInsertValue - Small helper function to be called only be insertVal.
|
2006-01-25 23:08:15 +00:00
|
|
|
int doInsertValue(const Value *V);
|
|
|
|
int doInsertType(const Type *T);
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2002-04-07 22:49:37 +00:00
|
|
|
// processModule - Process all of the module level function declarations and
|
2001-09-07 16:27:05 +00:00
|
|
|
// types that are available.
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2001-09-07 16:27:05 +00:00
|
|
|
void processModule();
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2001-09-07 16:27:05 +00:00
|
|
|
// processSymbolTable - Insert all of the values in the specified symbol table
|
|
|
|
// into the values table...
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2007-01-06 07:24:44 +00:00
|
|
|
void processTypeSymbolTable(const TypeSymbolTable *ST);
|
|
|
|
void processValueSymbolTable(const SymbolTable *ST);
|
2001-09-07 16:27:05 +00:00
|
|
|
void processSymbolTableConstants(const SymbolTable *ST);
|
2004-01-18 21:03:49 +00:00
|
|
|
|
|
|
|
void buildCompactionTable(const Function *F);
|
|
|
|
unsigned getOrCreateCompactionTableSlot(const Value *V);
|
2004-07-04 11:42:49 +00:00
|
|
|
unsigned getOrCreateCompactionTableSlot(const Type *V);
|
2004-01-20 00:54:47 +00:00
|
|
|
void pruneCompactionTable();
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
|
|
|
|
// insertPrimitives - helper for constructors to insert primitive types.
|
|
|
|
void insertPrimitives();
|
2001-06-06 20:29:01 +00:00
|
|
|
};
|
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
} // End llvm namespace
|
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
#endif
|