2007-04-22 06:24:45 +00:00
|
|
|
//===-- ValueEnumerator.cpp - Number values and types for bitcode writer --===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2007-04-22 06:24:45 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements the ValueEnumerator class.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "ValueEnumerator.h"
|
2011-04-06 16:49:37 +00:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Constants.h"
|
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
|
|
|
#include "llvm/IR/Instructions.h"
|
|
|
|
#include "llvm/IR/Module.h"
|
|
|
|
#include "llvm/IR/ValueSymbolTable.h"
|
2011-12-07 20:44:46 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2007-05-04 05:05:48 +00:00
|
|
|
#include <algorithm>
|
2007-04-22 06:24:45 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2012-11-13 12:59:33 +00:00
|
|
|
static bool isIntOrIntVectorValue(const std::pair<const Value*, unsigned> &V) {
|
|
|
|
return V.first->getType()->isIntOrIntVectorTy();
|
2007-05-04 05:21:47 +00:00
|
|
|
}
|
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
/// ValueEnumerator - Enumerate module-level information.
|
|
|
|
ValueEnumerator::ValueEnumerator(const Module *M) {
|
|
|
|
// Enumerate the global variables.
|
|
|
|
for (Module::const_global_iterator I = M->global_begin(),
|
|
|
|
E = M->global_end(); I != E; ++I)
|
|
|
|
EnumerateValue(I);
|
|
|
|
|
|
|
|
// Enumerate the functions.
|
2007-11-27 13:23:08 +00:00
|
|
|
for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) {
|
2007-04-22 06:24:45 +00:00
|
|
|
EnumerateValue(I);
|
2008-09-25 21:00:45 +00:00
|
|
|
EnumerateAttributes(cast<Function>(I)->getAttributes());
|
2007-11-27 13:23:08 +00:00
|
|
|
}
|
2007-04-22 06:24:45 +00:00
|
|
|
|
2007-04-26 02:46:40 +00:00
|
|
|
// Enumerate the aliases.
|
|
|
|
for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
|
|
|
|
I != E; ++I)
|
|
|
|
EnumerateValue(I);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 05:21:47 +00:00
|
|
|
// Remember what is the cutoff between globalvalue's and other constants.
|
|
|
|
unsigned FirstConstant = Values.size();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
// Enumerate the global variable initializers.
|
|
|
|
for (Module::const_global_iterator I = M->global_begin(),
|
|
|
|
E = M->global_end(); I != E; ++I)
|
|
|
|
if (I->hasInitializer())
|
|
|
|
EnumerateValue(I->getInitializer());
|
|
|
|
|
2007-04-26 02:46:40 +00:00
|
|
|
// Enumerate the aliasees.
|
|
|
|
for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
|
|
|
|
I != E; ++I)
|
|
|
|
EnumerateValue(I->getAliasee());
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2013-09-16 01:08:15 +00:00
|
|
|
// Enumerate the prefix data constants.
|
|
|
|
for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
|
|
|
|
if (I->hasPrefixData())
|
|
|
|
EnumerateValue(I->getPrefixData());
|
|
|
|
|
2013-04-01 02:28:07 +00:00
|
|
|
// Insert constants and metadata that are named at module level into the slot
|
2010-01-07 19:39:36 +00:00
|
|
|
// pool so that the module symbol table can refer to them...
|
2007-04-22 06:24:45 +00:00
|
|
|
EnumerateValueSymbolTable(M->getValueSymbolTable());
|
2010-07-21 23:38:33 +00:00
|
|
|
EnumerateNamedMetadata(M);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-12-31 00:51:46 +00:00
|
|
|
SmallVector<std::pair<unsigned, MDNode*>, 8> MDs;
|
|
|
|
|
2007-04-26 03:50:57 +00:00
|
|
|
// Enumerate types used by function bodies and argument lists.
|
2007-04-22 06:24:45 +00:00
|
|
|
for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) {
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-26 03:50:57 +00:00
|
|
|
for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
|
|
|
|
I != E; ++I)
|
|
|
|
EnumerateType(I->getType());
|
2009-09-18 19:26:43 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
|
|
|
|
for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E;++I){
|
2009-09-20 02:20:51 +00:00
|
|
|
for (User::const_op_iterator OI = I->op_begin(), E = I->op_end();
|
2010-01-14 19:54:11 +00:00
|
|
|
OI != E; ++OI) {
|
|
|
|
if (MDNode *MD = dyn_cast<MDNode>(*OI))
|
2010-02-06 01:21:09 +00:00
|
|
|
if (MD->isFunctionLocal() && MD->getFunction())
|
2010-01-14 19:54:11 +00:00
|
|
|
// These will get enumerated during function-incorporation.
|
|
|
|
continue;
|
|
|
|
EnumerateOperandType(*OI);
|
|
|
|
}
|
2007-04-22 06:24:45 +00:00
|
|
|
EnumerateType(I->getType());
|
2007-11-27 13:23:08 +00:00
|
|
|
if (const CallInst *CI = dyn_cast<CallInst>(I))
|
2008-09-25 21:00:45 +00:00
|
|
|
EnumerateAttributes(CI->getAttributes());
|
2007-11-27 13:23:08 +00:00
|
|
|
else if (const InvokeInst *II = dyn_cast<InvokeInst>(I))
|
2008-09-25 21:00:45 +00:00
|
|
|
EnumerateAttributes(II->getAttributes());
|
2009-09-18 19:26:43 +00:00
|
|
|
|
2009-09-20 02:20:51 +00:00
|
|
|
// Enumerate metadata attached with this instruction.
|
2009-10-22 18:55:16 +00:00
|
|
|
MDs.clear();
|
2010-04-03 02:17:50 +00:00
|
|
|
I->getAllMetadataOtherThanDebugLoc(MDs);
|
2009-12-28 23:41:32 +00:00
|
|
|
for (unsigned i = 0, e = MDs.size(); i != e; ++i)
|
2010-01-14 19:54:11 +00:00
|
|
|
EnumerateMetadata(MDs[i].second);
|
2012-11-25 15:23:39 +00:00
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
if (!I->getDebugLoc().isUnknown()) {
|
|
|
|
MDNode *Scope, *IA;
|
|
|
|
I->getDebugLoc().getScopeAndInlinedAt(Scope, IA, I->getContext());
|
|
|
|
if (Scope) EnumerateMetadata(Scope);
|
|
|
|
if (IA) EnumerateMetadata(IA);
|
|
|
|
}
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 05:21:47 +00:00
|
|
|
// Optimize constant ordering.
|
|
|
|
OptimizeConstants(FirstConstant, Values.size());
|
2011-04-06 16:49:37 +00:00
|
|
|
}
|
|
|
|
|
2009-09-18 19:26:43 +00:00
|
|
|
unsigned ValueEnumerator::getInstructionID(const Instruction *Inst) const {
|
|
|
|
InstructionMapType::const_iterator I = InstructionMap.find(Inst);
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
assert(I != InstructionMap.end() && "Instruction is not mapped!");
|
2010-08-25 17:09:50 +00:00
|
|
|
return I->second;
|
2009-09-20 02:20:51 +00:00
|
|
|
}
|
2009-09-18 19:26:43 +00:00
|
|
|
|
|
|
|
void ValueEnumerator::setInstructionID(const Instruction *I) {
|
|
|
|
InstructionMap[I] = InstructionCount++;
|
|
|
|
}
|
|
|
|
|
2009-08-04 06:00:18 +00:00
|
|
|
unsigned ValueEnumerator::getValueID(const Value *V) const {
|
2010-01-22 22:52:10 +00:00
|
|
|
if (isa<MDNode>(V) || isa<MDString>(V)) {
|
2009-08-04 06:00:18 +00:00
|
|
|
ValueMapType::const_iterator I = MDValueMap.find(V);
|
|
|
|
assert(I != MDValueMap.end() && "Value not in slotcalculator!");
|
|
|
|
return I->second-1;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-08-04 06:00:18 +00:00
|
|
|
ValueMapType::const_iterator I = ValueMap.find(V);
|
|
|
|
assert(I != ValueMap.end() && "Value not in slotcalculator!");
|
|
|
|
return I->second-1;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-12-07 20:44:46 +00:00
|
|
|
void ValueEnumerator::dump() const {
|
|
|
|
print(dbgs(), ValueMap, "Default");
|
|
|
|
dbgs() << '\n';
|
|
|
|
print(dbgs(), MDValueMap, "MetaData");
|
|
|
|
dbgs() << '\n';
|
|
|
|
}
|
|
|
|
|
|
|
|
void ValueEnumerator::print(raw_ostream &OS, const ValueMapType &Map,
|
|
|
|
const char *Name) const {
|
|
|
|
|
|
|
|
OS << "Map Name: " << Name << "\n";
|
|
|
|
OS << "Size: " << Map.size() << "\n";
|
|
|
|
for (ValueMapType::const_iterator I = Map.begin(),
|
|
|
|
E = Map.end(); I != E; ++I) {
|
|
|
|
|
|
|
|
const Value *V = I->first;
|
|
|
|
if (V->hasName())
|
|
|
|
OS << "Value: " << V->getName();
|
|
|
|
else
|
|
|
|
OS << "Value: [null]\n";
|
|
|
|
V->dump();
|
|
|
|
|
|
|
|
OS << " Uses(" << std::distance(V->use_begin(),V->use_end()) << "):";
|
|
|
|
for (Value::const_use_iterator UI = V->use_begin(), UE = V->use_end();
|
|
|
|
UI != UE; ++UI) {
|
|
|
|
if (UI != V->use_begin())
|
|
|
|
OS << ",";
|
|
|
|
if((*UI)->hasName())
|
|
|
|
OS << " " << (*UI)->getName();
|
|
|
|
else
|
|
|
|
OS << " [null]";
|
|
|
|
|
|
|
|
}
|
|
|
|
OS << "\n\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-04 05:21:47 +00:00
|
|
|
// Optimize constant ordering.
|
2008-05-13 00:00:25 +00:00
|
|
|
namespace {
|
|
|
|
struct CstSortPredicate {
|
|
|
|
ValueEnumerator &VE;
|
|
|
|
explicit CstSortPredicate(ValueEnumerator &ve) : VE(ve) {}
|
|
|
|
bool operator()(const std::pair<const Value*, unsigned> &LHS,
|
|
|
|
const std::pair<const Value*, unsigned> &RHS) {
|
|
|
|
// Sort by plane.
|
|
|
|
if (LHS.first->getType() != RHS.first->getType())
|
2009-09-20 02:20:51 +00:00
|
|
|
return VE.getTypeID(LHS.first->getType()) <
|
2008-05-13 00:00:25 +00:00
|
|
|
VE.getTypeID(RHS.first->getType());
|
|
|
|
// Then by frequency.
|
|
|
|
return LHS.second > RHS.second;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2007-05-04 05:21:47 +00:00
|
|
|
|
|
|
|
/// OptimizeConstants - Reorder constant pool for denser encoding.
|
|
|
|
void ValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) {
|
|
|
|
if (CstStart == CstEnd || CstStart+1 == CstEnd) return;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 05:21:47 +00:00
|
|
|
CstSortPredicate P(*this);
|
|
|
|
std::stable_sort(Values.begin()+CstStart, Values.begin()+CstEnd, P);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2012-11-13 12:59:33 +00:00
|
|
|
// Ensure that integer and vector of integer constants are at the start of the
|
|
|
|
// constant pool. This is important so that GEP structure indices come before
|
|
|
|
// gep constant exprs.
|
2007-05-04 05:21:47 +00:00
|
|
|
std::partition(Values.begin()+CstStart, Values.begin()+CstEnd,
|
2012-11-13 12:59:33 +00:00
|
|
|
isIntOrIntVectorValue);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 05:21:47 +00:00
|
|
|
// Rebuild the modified portion of ValueMap.
|
|
|
|
for (; CstStart != CstEnd; ++CstStart)
|
|
|
|
ValueMap[Values[CstStart].first] = CstStart+1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
/// EnumerateValueSymbolTable - Insert all of the values in the specified symbol
|
|
|
|
/// table into the values table.
|
|
|
|
void ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) {
|
2009-09-20 02:20:51 +00:00
|
|
|
for (ValueSymbolTable::const_iterator VI = VST.begin(), VE = VST.end();
|
2007-04-22 06:24:45 +00:00
|
|
|
VI != VE; ++VI)
|
|
|
|
EnumerateValue(VI->getValue());
|
|
|
|
}
|
|
|
|
|
2010-07-21 23:38:33 +00:00
|
|
|
/// EnumerateNamedMetadata - Insert all of the values referenced by
|
|
|
|
/// named metadata in the specified module.
|
|
|
|
void ValueEnumerator::EnumerateNamedMetadata(const Module *M) {
|
|
|
|
for (Module::const_named_metadata_iterator I = M->named_metadata_begin(),
|
|
|
|
E = M->named_metadata_end(); I != E; ++I)
|
|
|
|
EnumerateNamedMDNode(I);
|
2010-01-07 19:39:36 +00:00
|
|
|
}
|
|
|
|
|
2010-01-09 00:30:14 +00:00
|
|
|
void ValueEnumerator::EnumerateNamedMDNode(const NamedMDNode *MD) {
|
|
|
|
for (unsigned i = 0, e = MD->getNumOperands(); i != e; ++i)
|
2010-08-24 02:01:24 +00:00
|
|
|
EnumerateMetadata(MD->getOperand(i));
|
2010-01-09 00:30:14 +00:00
|
|
|
}
|
|
|
|
|
2010-08-24 02:24:03 +00:00
|
|
|
/// EnumerateMDNodeOperands - Enumerate all non-function-local values
|
|
|
|
/// and types referenced by the given MDNode.
|
|
|
|
void ValueEnumerator::EnumerateMDNodeOperands(const MDNode *N) {
|
|
|
|
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
|
|
|
|
if (Value *V = N->getOperand(i)) {
|
|
|
|
if (isa<MDNode>(V) || isa<MDString>(V))
|
|
|
|
EnumerateMetadata(V);
|
|
|
|
else if (!isa<Instruction>(V) && !isa<Argument>(V))
|
|
|
|
EnumerateValue(V);
|
|
|
|
} else
|
|
|
|
EnumerateType(Type::getVoidTy(N->getContext()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-22 22:52:10 +00:00
|
|
|
void ValueEnumerator::EnumerateMetadata(const Value *MD) {
|
2010-01-23 09:54:23 +00:00
|
|
|
assert((isa<MDNode>(MD) || isa<MDString>(MD)) && "Invalid metadata kind");
|
2010-08-24 02:24:03 +00:00
|
|
|
|
|
|
|
// Enumerate the type of this value.
|
|
|
|
EnumerateType(MD->getType());
|
|
|
|
|
|
|
|
const MDNode *N = dyn_cast<MDNode>(MD);
|
|
|
|
|
|
|
|
// In the module-level pass, skip function-local nodes themselves, but
|
|
|
|
// do walk their operands.
|
|
|
|
if (N && N->isFunctionLocal() && N->getFunction()) {
|
|
|
|
EnumerateMDNodeOperands(N);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-08-04 06:00:18 +00:00
|
|
|
// Check to see if it's already in!
|
|
|
|
unsigned &MDValueID = MDValueMap[MD];
|
|
|
|
if (MDValueID) {
|
|
|
|
// Increment use count.
|
|
|
|
MDValues[MDValueID-1].second++;
|
|
|
|
return;
|
|
|
|
}
|
2010-08-24 02:24:03 +00:00
|
|
|
MDValues.push_back(std::make_pair(MD, 1U));
|
|
|
|
MDValueID = MDValues.size();
|
|
|
|
|
|
|
|
// Enumerate all non-function-local operands.
|
|
|
|
if (N)
|
|
|
|
EnumerateMDNodeOperands(N);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// EnumerateFunctionLocalMetadataa - Incorporate function-local metadata
|
|
|
|
/// information reachable from the given MDNode.
|
|
|
|
void ValueEnumerator::EnumerateFunctionLocalMetadata(const MDNode *N) {
|
|
|
|
assert(N->isFunctionLocal() && N->getFunction() &&
|
|
|
|
"EnumerateFunctionLocalMetadata called on non-function-local mdnode!");
|
2009-08-04 06:00:18 +00:00
|
|
|
|
|
|
|
// Enumerate the type of this value.
|
2010-08-24 02:24:03 +00:00
|
|
|
EnumerateType(N->getType());
|
2009-08-04 06:00:18 +00:00
|
|
|
|
2010-08-24 02:24:03 +00:00
|
|
|
// Check to see if it's already in!
|
|
|
|
unsigned &MDValueID = MDValueMap[N];
|
|
|
|
if (MDValueID) {
|
|
|
|
// Increment use count.
|
|
|
|
MDValues[MDValueID-1].second++;
|
2009-08-04 06:00:18 +00:00
|
|
|
return;
|
2009-10-28 05:24:40 +00:00
|
|
|
}
|
2010-08-24 02:24:03 +00:00
|
|
|
MDValues.push_back(std::make_pair(N, 1U));
|
2009-08-04 06:00:18 +00:00
|
|
|
MDValueID = MDValues.size();
|
2010-08-24 02:24:03 +00:00
|
|
|
|
|
|
|
// To incoroporate function-local information visit all function-local
|
|
|
|
// MDNodes and all function-local values they reference.
|
|
|
|
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
|
|
|
|
if (Value *V = N->getOperand(i)) {
|
2010-08-24 02:40:27 +00:00
|
|
|
if (MDNode *O = dyn_cast<MDNode>(V)) {
|
2010-08-24 02:24:03 +00:00
|
|
|
if (O->isFunctionLocal() && O->getFunction())
|
|
|
|
EnumerateFunctionLocalMetadata(O);
|
2010-08-24 02:40:27 +00:00
|
|
|
} else if (isa<Instruction>(V) || isa<Argument>(V))
|
2010-08-24 02:24:03 +00:00
|
|
|
EnumerateValue(V);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Also, collect all function-local MDNodes for easy access.
|
|
|
|
FunctionLocalMDs.push_back(N);
|
2009-08-04 06:00:18 +00:00
|
|
|
}
|
|
|
|
|
2010-01-14 19:54:11 +00:00
|
|
|
void ValueEnumerator::EnumerateValue(const Value *V) {
|
2009-12-31 00:51:46 +00:00
|
|
|
assert(!V->getType()->isVoidTy() && "Can't insert void values!");
|
2010-08-24 02:24:03 +00:00
|
|
|
assert(!isa<MDNode>(V) && !isa<MDString>(V) &&
|
|
|
|
"EnumerateValue doesn't handle Metadata!");
|
2009-08-04 06:00:18 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
// Check to see if it's already in!
|
|
|
|
unsigned &ValueID = ValueMap[V];
|
|
|
|
if (ValueID) {
|
|
|
|
// Increment use count.
|
|
|
|
Values[ValueID-1].second++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-05-06 01:00:28 +00:00
|
|
|
// Enumerate the type of this value.
|
|
|
|
EnumerateType(V->getType());
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
if (const Constant *C = dyn_cast<Constant>(V)) {
|
|
|
|
if (isa<GlobalValue>(C)) {
|
|
|
|
// Initializers for globals are handled explicitly elsewhere.
|
2007-05-06 01:00:28 +00:00
|
|
|
} else if (C->getNumOperands()) {
|
|
|
|
// If a constant has operands, enumerate them. This makes sure that if a
|
|
|
|
// constant has uses (for example an array of const ints), that they are
|
|
|
|
// inserted also.
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 01:00:28 +00:00
|
|
|
// We prefer to enumerate them with values before we enumerate the user
|
|
|
|
// itself. This makes it more likely that we can avoid forward references
|
|
|
|
// in the reader. We know that there can be no cycles in the constants
|
|
|
|
// graph that don't go through a global variable.
|
2007-04-22 06:24:45 +00:00
|
|
|
for (User::const_op_iterator I = C->op_begin(), E = C->op_end();
|
|
|
|
I != E; ++I)
|
2009-11-01 01:27:45 +00:00
|
|
|
if (!isa<BasicBlock>(*I)) // Don't enumerate BB operand to BlockAddress.
|
2010-01-14 19:54:11 +00:00
|
|
|
EnumerateValue(*I);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 01:00:28 +00:00
|
|
|
// Finally, add the value. Doing this could make the ValueID reference be
|
|
|
|
// dangling, don't reuse it.
|
2009-05-10 20:57:05 +00:00
|
|
|
Values.push_back(std::make_pair(V, 1U));
|
|
|
|
ValueMap[V] = Values.size();
|
|
|
|
return;
|
2009-07-23 01:07:34 +00:00
|
|
|
}
|
|
|
|
}
|
2009-05-10 20:57:05 +00:00
|
|
|
|
2007-05-06 01:00:28 +00:00
|
|
|
// Add the value.
|
|
|
|
Values.push_back(std::make_pair(V, 1U));
|
|
|
|
ValueID = Values.size();
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
void ValueEnumerator::EnumerateType(Type *Ty) {
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
unsigned *TypeID = &TypeMap[Ty];
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-04-06 16:49:37 +00:00
|
|
|
// We've already seen this type.
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
if (*TypeID)
|
2007-04-22 06:24:45 +00:00
|
|
|
return;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
// If it is a non-anonymous struct, mark the type as being visited so that we
|
|
|
|
// don't recursively visit it. This is safe because we allow forward
|
|
|
|
// references of these in the bitcode reader.
|
2011-07-18 04:54:35 +00:00
|
|
|
if (StructType *STy = dyn_cast<StructType>(Ty))
|
2011-08-12 18:06:37 +00:00
|
|
|
if (!STy->isLiteral())
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
*TypeID = ~0U;
|
2012-11-25 15:23:39 +00:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
// Enumerate all of the subtypes before we enumerate this type. This ensures
|
|
|
|
// that the type will be enumerated in an order that can be directly built.
|
2007-04-22 06:24:45 +00:00
|
|
|
for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end();
|
|
|
|
I != E; ++I)
|
|
|
|
EnumerateType(*I);
|
2012-11-25 15:23:39 +00:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
// Refresh the TypeID pointer in case the table rehashed.
|
|
|
|
TypeID = &TypeMap[Ty];
|
2012-11-25 15:23:39 +00:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
// Check to see if we got the pointer another way. This can happen when
|
|
|
|
// enumerating recursive types that hit the base case deeper than they start.
|
|
|
|
//
|
|
|
|
// If this is actually a struct that we are treating as forward ref'able,
|
|
|
|
// then emit the definition now that all of its contents are available.
|
|
|
|
if (*TypeID && *TypeID != ~0U)
|
|
|
|
return;
|
2012-11-25 15:23:39 +00:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
// Add this type now that its contents are all happily enumerated.
|
|
|
|
Types.push_back(Ty);
|
2012-11-25 15:23:39 +00:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
*TypeID = Types.size();
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
|
|
|
|
2007-05-06 08:35:19 +00:00
|
|
|
// Enumerate the types for the specified value. If the value is a constant,
|
|
|
|
// walk through it, enumerating the types of the constant.
|
2010-01-14 19:54:11 +00:00
|
|
|
void ValueEnumerator::EnumerateOperandType(const Value *V) {
|
2007-05-06 08:35:19 +00:00
|
|
|
EnumerateType(V->getType());
|
2012-11-25 15:23:39 +00:00
|
|
|
|
2007-05-06 08:35:19 +00:00
|
|
|
if (const Constant *C = dyn_cast<Constant>(V)) {
|
|
|
|
// If this constant is already enumerated, ignore it, we know its type must
|
|
|
|
// be enumerated.
|
|
|
|
if (ValueMap.count(V)) return;
|
|
|
|
|
|
|
|
// This constant may have operands, make sure to enumerate the types in
|
|
|
|
// them.
|
2009-10-28 05:24:40 +00:00
|
|
|
for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) {
|
2011-04-11 09:48:55 +00:00
|
|
|
const Value *Op = C->getOperand(i);
|
2012-11-25 15:23:39 +00:00
|
|
|
|
2009-10-28 05:24:40 +00:00
|
|
|
// Don't enumerate basic blocks here, this happens as operands to
|
|
|
|
// blockaddress.
|
|
|
|
if (isa<BasicBlock>(Op)) continue;
|
2012-11-25 15:23:39 +00:00
|
|
|
|
2010-08-25 17:09:03 +00:00
|
|
|
EnumerateOperandType(Op);
|
2009-10-28 05:24:40 +00:00
|
|
|
}
|
2009-05-10 20:57:05 +00:00
|
|
|
|
|
|
|
if (const MDNode *N = dyn_cast<MDNode>(V)) {
|
2009-12-31 01:22:29 +00:00
|
|
|
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
|
|
|
|
if (Value *Elem = N->getOperand(i))
|
2010-01-14 19:54:11 +00:00
|
|
|
EnumerateOperandType(Elem);
|
2009-05-10 20:57:05 +00:00
|
|
|
}
|
2009-07-23 01:07:34 +00:00
|
|
|
} else if (isa<MDString>(V) || isa<MDNode>(V))
|
2010-08-24 02:10:52 +00:00
|
|
|
EnumerateMetadata(V);
|
2007-05-06 08:35:19 +00:00
|
|
|
}
|
|
|
|
|
2013-02-12 08:01:22 +00:00
|
|
|
void ValueEnumerator::EnumerateAttributes(AttributeSet PAL) {
|
2008-03-12 17:45:29 +00:00
|
|
|
if (PAL.isEmpty()) return; // null is always 0.
|
2013-02-12 08:01:22 +00:00
|
|
|
|
2007-05-03 22:46:43 +00:00
|
|
|
// Do a lookup.
|
2013-02-12 08:01:22 +00:00
|
|
|
unsigned &Entry = AttributeMap[PAL];
|
2007-05-03 22:46:43 +00:00
|
|
|
if (Entry == 0) {
|
|
|
|
// Never saw this before, add it.
|
2012-12-19 07:18:57 +00:00
|
|
|
Attribute.push_back(PAL);
|
|
|
|
Entry = Attribute.size();
|
2007-05-03 22:46:43 +00:00
|
|
|
}
|
2013-02-10 23:06:02 +00:00
|
|
|
|
|
|
|
// Do lookups for all attribute groups.
|
|
|
|
for (unsigned i = 0, e = PAL.getNumSlots(); i != e; ++i) {
|
|
|
|
AttributeSet AS = PAL.getSlotAttributes(i);
|
2013-02-11 22:33:26 +00:00
|
|
|
unsigned &Entry = AttributeGroupMap[AS];
|
2013-02-10 23:06:02 +00:00
|
|
|
if (Entry == 0) {
|
2013-02-11 22:33:26 +00:00
|
|
|
AttributeGroups.push_back(AS);
|
|
|
|
Entry = AttributeGroups.size();
|
2013-02-10 23:06:02 +00:00
|
|
|
}
|
|
|
|
}
|
2007-05-03 22:46:43 +00:00
|
|
|
}
|
|
|
|
|
2011-06-03 17:02:19 +00:00
|
|
|
void ValueEnumerator::incorporateFunction(const Function &F) {
|
2010-02-25 08:30:17 +00:00
|
|
|
InstructionCount = 0;
|
2007-04-26 05:53:54 +00:00
|
|
|
NumModuleValues = Values.size();
|
2010-08-24 02:24:03 +00:00
|
|
|
NumModuleMDValues = MDValues.size();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-26 03:50:57 +00:00
|
|
|
// Adding function arguments to the value table.
|
2010-07-16 22:58:39 +00:00
|
|
|
for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end();
|
|
|
|
I != E; ++I)
|
2007-04-26 03:50:57 +00:00
|
|
|
EnumerateValue(I);
|
|
|
|
|
2007-04-26 05:53:54 +00:00
|
|
|
FirstFuncConstantID = Values.size();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-26 03:50:57 +00:00
|
|
|
// Add all function-level constants to the value table.
|
|
|
|
for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
|
|
|
|
for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I)
|
2009-09-20 02:20:51 +00:00
|
|
|
for (User::const_op_iterator OI = I->op_begin(), E = I->op_end();
|
2007-04-26 03:50:57 +00:00
|
|
|
OI != E; ++OI) {
|
|
|
|
if ((isa<Constant>(*OI) && !isa<GlobalValue>(*OI)) ||
|
|
|
|
isa<InlineAsm>(*OI))
|
|
|
|
EnumerateValue(*OI);
|
|
|
|
}
|
2007-04-26 04:42:16 +00:00
|
|
|
BasicBlocks.push_back(BB);
|
2007-05-03 22:18:21 +00:00
|
|
|
ValueMap[BB] = BasicBlocks.size();
|
2007-04-26 03:50:57 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 05:21:47 +00:00
|
|
|
// Optimize the constant layout.
|
|
|
|
OptimizeConstants(FirstFuncConstantID, Values.size());
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-11-27 13:23:08 +00:00
|
|
|
// Add the function's parameter attributes so they are available for use in
|
|
|
|
// the function's instruction.
|
2008-09-25 21:00:45 +00:00
|
|
|
EnumerateAttributes(F.getAttributes());
|
2007-11-27 13:23:08 +00:00
|
|
|
|
2007-04-26 05:53:54 +00:00
|
|
|
FirstInstID = Values.size();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-06-02 23:05:04 +00:00
|
|
|
SmallVector<MDNode *, 8> FnLocalMDVector;
|
2007-04-26 03:50:57 +00:00
|
|
|
// Add all of the instructions.
|
|
|
|
for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
|
2007-04-22 06:24:45 +00:00
|
|
|
for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) {
|
2010-01-13 19:36:16 +00:00
|
|
|
for (User::const_op_iterator OI = I->op_begin(), E = I->op_end();
|
|
|
|
OI != E; ++OI) {
|
2010-01-14 19:54:11 +00:00
|
|
|
if (MDNode *MD = dyn_cast<MDNode>(*OI))
|
2010-02-06 01:21:09 +00:00
|
|
|
if (MD->isFunctionLocal() && MD->getFunction())
|
2010-02-04 01:13:08 +00:00
|
|
|
// Enumerate metadata after the instructions they might refer to.
|
2010-06-02 23:05:04 +00:00
|
|
|
FnLocalMDVector.push_back(MD);
|
2010-01-13 19:36:16 +00:00
|
|
|
}
|
2010-08-24 02:24:03 +00:00
|
|
|
|
|
|
|
SmallVector<std::pair<unsigned, MDNode*>, 8> MDs;
|
|
|
|
I->getAllMetadataOtherThanDebugLoc(MDs);
|
|
|
|
for (unsigned i = 0, e = MDs.size(); i != e; ++i) {
|
|
|
|
MDNode *N = MDs[i].second;
|
|
|
|
if (N->isFunctionLocal() && N->getFunction())
|
|
|
|
FnLocalMDVector.push_back(N);
|
|
|
|
}
|
2012-11-25 15:23:39 +00:00
|
|
|
|
2010-01-05 13:12:22 +00:00
|
|
|
if (!I->getType()->isVoidTy())
|
2007-04-26 03:50:57 +00:00
|
|
|
EnumerateValue(I);
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
|
|
|
}
|
2010-02-04 01:13:08 +00:00
|
|
|
|
|
|
|
// Add all of the function-local metadata.
|
2010-06-02 23:05:04 +00:00
|
|
|
for (unsigned i = 0, e = FnLocalMDVector.size(); i != e; ++i)
|
2010-08-24 02:24:03 +00:00
|
|
|
EnumerateFunctionLocalMetadata(FnLocalMDVector[i]);
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
|
|
|
|
2011-06-03 17:02:19 +00:00
|
|
|
void ValueEnumerator::purgeFunction() {
|
2007-04-26 03:50:57 +00:00
|
|
|
/// Remove purged values from the ValueMap.
|
2007-04-26 05:53:54 +00:00
|
|
|
for (unsigned i = NumModuleValues, e = Values.size(); i != e; ++i)
|
2007-04-26 03:50:57 +00:00
|
|
|
ValueMap.erase(Values[i].first);
|
2010-08-24 02:24:03 +00:00
|
|
|
for (unsigned i = NumModuleMDValues, e = MDValues.size(); i != e; ++i)
|
|
|
|
MDValueMap.erase(MDValues[i].first);
|
2007-04-26 04:42:16 +00:00
|
|
|
for (unsigned i = 0, e = BasicBlocks.size(); i != e; ++i)
|
|
|
|
ValueMap.erase(BasicBlocks[i]);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-26 05:53:54 +00:00
|
|
|
Values.resize(NumModuleValues);
|
2010-08-24 02:24:03 +00:00
|
|
|
MDValues.resize(NumModuleMDValues);
|
2007-04-26 04:42:16 +00:00
|
|
|
BasicBlocks.clear();
|
2010-08-25 17:11:16 +00:00
|
|
|
FunctionLocalMDs.clear();
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
2009-10-28 05:24:40 +00:00
|
|
|
|
|
|
|
static void IncorporateFunctionInfoGlobalBBIDs(const Function *F,
|
|
|
|
DenseMap<const BasicBlock*, unsigned> &IDMap) {
|
|
|
|
unsigned Counter = 0;
|
|
|
|
for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
|
|
|
|
IDMap[BB] = ++Counter;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// getGlobalBasicBlockID - This returns the function-specific ID for the
|
|
|
|
/// specified basic block. This is relatively expensive information, so it
|
|
|
|
/// should only be used by rare constructs such as address-of-label.
|
|
|
|
unsigned ValueEnumerator::getGlobalBasicBlockID(const BasicBlock *BB) const {
|
|
|
|
unsigned &Idx = GlobalBasicBlockIDs[BB];
|
|
|
|
if (Idx != 0)
|
2009-11-01 01:27:45 +00:00
|
|
|
return Idx-1;
|
2009-10-28 05:24:40 +00:00
|
|
|
|
|
|
|
IncorporateFunctionInfoGlobalBBIDs(BB->getParent(), GlobalBasicBlockIDs);
|
|
|
|
return getGlobalBasicBlockID(BB);
|
|
|
|
}
|
|
|
|
|