//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Chris Lattner and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
//===----------------------------------------------------------------------===//
#include "ValueEnumerator.h"
+#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
+#include "llvm/MDNode.h"
#include "llvm/Module.h"
#include "llvm/TypeSymbolTable.h"
#include "llvm/ValueSymbolTable.h"
+#include "llvm/Instructions.h"
+#include <algorithm>
using namespace llvm;
+static bool isSingleValueType(const std::pair<const llvm::Type*,
+ unsigned int> &P) {
+ return P.first->isSingleValueType();
+}
+
+static bool isIntegerValue(const std::pair<const Value*, unsigned> &V) {
+ return isa<IntegerType>(V.first->getType());
+}
+
+static bool CompareByFrequency(const std::pair<const llvm::Type*,
+ unsigned int> &P1,
+ const std::pair<const llvm::Type*,
+ unsigned int> &P2) {
+ return P1.second > P2.second;
+}
+
/// ValueEnumerator - Enumerate module-level information.
ValueEnumerator::ValueEnumerator(const Module *M) {
// Enumerate the global variables.
EnumerateValue(I);
// Enumerate the functions.
- for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
+ for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) {
EnumerateValue(I);
+ EnumerateAttributes(cast<Function>(I)->getAttributes());
+ }
// Enumerate the aliases.
for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
I != E; ++I)
EnumerateValue(I);
+ // Remember what is the cutoff between globalvalue's and other constants.
+ unsigned FirstConstant = Values.size();
+
// Enumerate the global variable initializers.
for (Module::const_global_iterator I = M->global_begin(),
E = M->global_end(); I != E; ++I)
I != E; ++I)
EnumerateValue(I->getAliasee());
- // FIXME: Implement the 'string constant' optimization.
-
// Enumerate types used by the type symbol table.
EnumerateTypeSymbolTable(M->getTypeSymbolTable());
for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E;++I){
for (User::const_op_iterator OI = I->op_begin(), E = I->op_end();
OI != E; ++OI)
- EnumerateType((*OI)->getType());
+ EnumerateOperandType(*OI);
EnumerateType(I->getType());
+ if (const CallInst *CI = dyn_cast<CallInst>(I))
+ EnumerateAttributes(CI->getAttributes());
+ else if (const InvokeInst *II = dyn_cast<InvokeInst>(I))
+ EnumerateAttributes(II->getAttributes());
}
}
+
+ // Optimize constant ordering.
+ OptimizeConstants(FirstConstant, Values.size());
+ // Sort the type table by frequency so that most commonly used types are early
+ // in the table (have low bit-width).
+ std::stable_sort(Types.begin(), Types.end(), CompareByFrequency);
+
+ // Partition the Type ID's so that the single-value types occur before the
+ // aggregate types. This allows the aggregate types to be dropped from the
+ // type table after parsing the global variable initializers.
+ std::partition(Types.begin(), Types.end(), isSingleValueType);
+
+ // Now that we rearranged the type table, rebuild TypeMap.
+ for (unsigned i = 0, e = Types.size(); i != e; ++i)
+ TypeMap[Types[i].first] = i+1;
+}
+
+// Optimize constant ordering.
+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())
+ return VE.getTypeID(LHS.first->getType()) <
+ VE.getTypeID(RHS.first->getType());
+ // Then by frequency.
+ return LHS.second > RHS.second;
+ }
+ };
+}
+
+/// OptimizeConstants - Reorder constant pool for denser encoding.
+void ValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) {
+ if (CstStart == CstEnd || CstStart+1 == CstEnd) return;
- // FIXME: std::partition the type and value tables so that first-class types
- // come earlier than aggregates. FIXME: Emit a marker into the module
- // indicating which aggregates types AND values can be dropped form the table.
+ CstSortPredicate P(*this);
+ std::stable_sort(Values.begin()+CstStart, Values.begin()+CstEnd, P);
- // FIXME: Sort type/value tables by frequency.
-
- // FIXME: Sort constants by type to reduce size.
+ // Ensure that integer constants are at the start of the constant pool. This
+ // is important so that GEP structure indices come before gep constant exprs.
+ std::partition(Values.begin()+CstStart, Values.begin()+CstEnd,
+ isIntegerValue);
+
+ // Rebuild the modified portion of ValueMap.
+ for (; CstStart != CstEnd; ++CstStart)
+ ValueMap[Values[CstStart].first] = CstStart+1;
}
+
/// EnumerateTypeSymbolTable - Insert all of the types in the specified symbol
/// table.
void ValueEnumerator::EnumerateTypeSymbolTable(const TypeSymbolTable &TST) {
Values[ValueID-1].second++;
return;
}
-
- // Add the value.
- Values.push_back(std::make_pair(V, 1U));
- ValueID = Values.size();
+ // Enumerate the type of this value.
+ EnumerateType(V->getType());
+
if (const Constant *C = dyn_cast<Constant>(V)) {
if (isa<GlobalValue>(C)) {
// Initializers for globals are handled explicitly elsewhere.
- } else {
- // This makes sure that if a constant has uses (for example an array of
- // const ints), that they are inserted also.
+ } else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) {
+ // Do not enumerate the initializers for an array of simple characters.
+ // The initializers just polute the value table, and we emit the strings
+ // specially.
+ } 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.
+
+ // 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.
for (User::const_op_iterator I = C->op_begin(), E = C->op_end();
I != E; ++I)
EnumerateValue(*I);
+
+ // Finally, add the value. Doing this could make the ValueID reference be
+ // dangling, don't reuse it.
+ Values.push_back(std::make_pair(V, 1U));
+ ValueMap[V] = Values.size();
+ return;
}
}
- EnumerateType(V->getType());
+ if (const MDNode *N = dyn_cast<MDNode>(V)) {
+ Values.push_back(std::make_pair(V, 1U));
+ ValueMap[V] = Values.size();
+ ValueID = Values.size();
+ for (MDNode::const_elem_iterator I = N->elem_begin(), E = N->elem_end();
+ I != E; ++I) {
+ if (*I)
+ EnumerateValue(*I);
+ else
+ EnumerateType(Type::VoidTy);
+ }
+ return;
+ }
+
+ // Add the value.
+ Values.push_back(std::make_pair(V, 1U));
+ ValueID = Values.size();
}
for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end();
I != E; ++I)
EnumerateType(*I);
-
- // If this is a function type, enumerate the param attrs.
- if (const FunctionType *FTy = dyn_cast<FunctionType>(Ty))
- EnumerateParamAttrs(FTy->getParamAttrs());
}
-void ValueEnumerator::EnumerateParamAttrs(const ParamAttrsList *PAL) {
- if (PAL == 0) return; // null is always 0.
+// Enumerate the types for the specified value. If the value is a constant,
+// walk through it, enumerating the types of the constant.
+void ValueEnumerator::EnumerateOperandType(const Value *V) {
+ EnumerateType(V->getType());
+ 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.
+ for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i)
+ EnumerateOperandType(C->getOperand(i));
+
+ if (const MDNode *N = dyn_cast<MDNode>(V)) {
+ for (unsigned i = 0, e = N->getNumElements(); i != e; ++i) {
+ Value *Elem = N->getElement(i);
+ if (Elem)
+ EnumerateOperandType(Elem);
+ }
+ }
+ } else if (isa<MDString>(V) || isa<MDNode>(V))
+ EnumerateValue(V);
+}
+
+void ValueEnumerator::EnumerateAttributes(const AttrListPtr &PAL) {
+ if (PAL.isEmpty()) return; // null is always 0.
// Do a lookup.
- unsigned &Entry = ParamAttrMap[PAL];
+ unsigned &Entry = AttributeMap[PAL.getRawPointer()];
if (Entry == 0) {
// Never saw this before, add it.
- ParamAttrs.push_back(PAL);
- Entry = ParamAttrs.size();
+ Attributes.push_back(PAL);
+ Entry = Attributes.size();
}
}
-/// PurgeAggregateValues - If there are any aggregate values at the end of the
-/// value list, remove them and return the count of the remaining values. If
-/// there are none, return -1.
-int ValueEnumerator::PurgeAggregateValues() {
- // If there are no aggregate values at the end of the list, return -1.
- if (Values.empty() || Values.back().first->getType()->isFirstClassType())
- return -1;
-
- // Otherwise, remove aggregate values...
- while (!Values.empty() && !Values.back().first->getType()->isFirstClassType())
- Values.pop_back();
-
- // ... and return the new size.
- return Values.size();
-}
-
void ValueEnumerator::incorporateFunction(const Function &F) {
NumModuleValues = Values.size();
ValueMap[BB] = BasicBlocks.size();
}
+ // Optimize the constant layout.
+ OptimizeConstants(FirstFuncConstantID, Values.size());
+
+ // Add the function's parameter attributes so they are available for use in
+ // the function's instruction.
+ EnumerateAttributes(F.getAttributes());
+
FirstInstID = Values.size();
// Add all of the instructions.
projects / oota-llvm.git / blobdiff