#include "llvm/Support/StringExtras.h" // itostr
#include "llvm/DerivedTypes.h"
#include "llvm/SymbolTable.h"
+#include "llvm/GlobalValue.h"
+#include "llvm/Module.h"
+#include "llvm/Analysis/SlotCalculator.h"
#include <algorithm>
#include <assert.h>
case Type::DoubleTyID: return ConstPoolFP::get(Ty, 0);
case Type::PointerTyID:
- return ConstPoolPointer::getNullPointer(Ty->castPointerType());
+ return ConstPoolPointerNull::get(cast<PointerType>(Ty));
default:
return 0;
}
}
+#ifndef NDEBUG
+#include "llvm/Assembly/Writer.h"
+#endif
+
+void ConstPoolVal::destroyConstantImpl() {
+ // When a ConstPoolVal is destroyed, there may be lingering
+ // references to the constant by other constants in the constant pool. These
+ // constants are implicitly dependant on the module that is being deleted,
+ // but they don't know that. Because we only find out when the CPV is
+ // deleted, we must now notify all of our users (that should only be
+ // ConstPoolVals) that they are, in fact, invalid now and should be deleted.
+ //
+ while (!use_empty()) {
+ Value *V = use_back();
+#ifndef NDEBUG // Only in -g mode...
+ if (!isa<ConstPoolVal>(V)) {
+ cerr << "While deleting: " << this << endl;
+ cerr << "Use still stuck around after Def is destroyed: " << V << endl;
+ }
+#endif
+ assert(isa<ConstPoolVal>(V) && "References remain to ConstPoolPointerRef!");
+ ConstPoolVal *CPV = cast<ConstPoolVal>(V);
+ CPV->destroyConstant();
+
+ // The constant should remove itself from our use list...
+ assert((use_empty() || use_back() == V) && "Constant not removed!");
+ }
+ // Value has no outstanding references it is safe to delete it now...
+ delete this;
+}
//===----------------------------------------------------------------------===//
// ConstPoolXXX Classes
}
}
-ConstPoolPointer::ConstPoolPointer(const PointerType *T) : ConstPoolVal(T) {}
+ConstPoolPointerRef::ConstPoolPointerRef(GlobalValue *GV)
+ : ConstPoolPointer(GV->getType()) {
+ Operands.push_back(Use(GV, this));
+}
+
//===----------------------------------------------------------------------===//
}
string ConstPoolArray::getStrValue() const {
- string Result = "[";
- if (Operands.size()) {
- Result += " " + Operands[0]->getType()->getDescription() +
- " " + Operands[0]->castConstantAsserting()->getStrValue();
- for (unsigned i = 1; i < Operands.size(); i++)
- Result += ", " + Operands[i]->getType()->getDescription() +
- " " + Operands[i]->castConstantAsserting()->getStrValue();
+ string Result;
+
+ // As a special case, print the array as a string if it is an array of
+ // ubytes or an array of sbytes with positive values.
+ //
+ const Type *ETy = cast<ArrayType>(getType())->getElementType();
+ bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy);
+
+ if (ETy == Type::SByteTy) {
+ for (unsigned i = 0; i < Operands.size(); ++i)
+ if (ETy == Type::SByteTy &&
+ cast<ConstPoolSInt>(Operands[i])->getValue() < 0) {
+ isString = false;
+ break;
+ }
}
- return Result + " ]";
+ if (isString) {
+ Result = "c\"";
+ for (unsigned i = 0; i < Operands.size(); ++i) {
+ unsigned char C = (ETy == Type::SByteTy) ?
+ (unsigned char)cast<ConstPoolSInt>(Operands[i])->getValue() :
+ (unsigned char)cast<ConstPoolUInt>(Operands[i])->getValue();
+
+ if (isprint(C)) {
+ Result += C;
+ } else {
+ Result += '\\';
+ Result += ( C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A');
+ Result += ((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A');
+ }
+ }
+ Result += "\"";
+
+ } else {
+ Result = "[";
+ if (Operands.size()) {
+ Result += " " + Operands[0]->getType()->getDescription() +
+ " " + cast<ConstPoolVal>(Operands[0])->getStrValue();
+ for (unsigned i = 1; i < Operands.size(); i++)
+ Result += ", " + Operands[i]->getType()->getDescription() +
+ " " + cast<ConstPoolVal>(Operands[i])->getStrValue();
+ }
+ Result += " ]";
+ }
+
+ return Result;
}
string ConstPoolStruct::getStrValue() const {
string Result = "{";
if (Operands.size()) {
Result += " " + Operands[0]->getType()->getDescription() +
- " " + Operands[0]->castConstantAsserting()->getStrValue();
+ " " + cast<ConstPoolVal>(Operands[0])->getStrValue();
for (unsigned i = 1; i < Operands.size(); i++)
Result += ", " + Operands[i]->getType()->getDescription() +
- " " + Operands[i]->castConstantAsserting()->getStrValue();
+ " " + cast<ConstPoolVal>(Operands[i])->getStrValue();
}
return Result + " }";
}
-string ConstPoolPointer::getStrValue() const {
+string ConstPoolPointerNull::getStrValue() const {
return "null";
}
+string ConstPoolPointerRef::getStrValue() const {
+ const GlobalValue *V = getValue();
+ if (V->hasName()) return "%" + V->getName();
+
+ SlotCalculator *Table = new SlotCalculator(V->getParent(), true);
+ int Slot = Table->getValSlot(V);
+ delete Table;
+
+ if (Slot >= 0) return string(" %") + itostr(Slot);
+ else return "<pointer reference badref>";
+}
+
+
+//===----------------------------------------------------------------------===//
+// classof implementations
+
+bool ConstPoolInt::classof(const ConstPoolVal *CPV) {
+ return CPV->getType()->isIntegral();
+}
+bool ConstPoolSInt::classof(const ConstPoolVal *CPV) {
+ return CPV->getType()->isSigned();
+}
+bool ConstPoolUInt::classof(const ConstPoolVal *CPV) {
+ return CPV->getType()->isUnsigned();
+}
+bool ConstPoolFP::classof(const ConstPoolVal *CPV) {
+ const Type *Ty = CPV->getType();
+ return Ty == Type::FloatTy || Ty == Type::DoubleTy;
+}
+bool ConstPoolArray::classof(const ConstPoolVal *CPV) {
+ return isa<ArrayType>(CPV->getType());
+}
+bool ConstPoolStruct::classof(const ConstPoolVal *CPV) {
+ return isa<StructType>(CPV->getType());
+}
+bool ConstPoolPointer::classof(const ConstPoolVal *CPV) {
+ return isa<PointerType>(CPV->getType());
+}
+
+
//===----------------------------------------------------------------------===//
// isValueValidForType implementations
inline void add(const Type *Ty, ValType V, ConstPoolClass *CP) {
Map.insert(make_pair(ConstHashKey(Ty, V), CP));
}
+
+ inline void remove(ConstPoolClass *CP) {
+ for (map<ConstHashKey,ConstPoolClass *>::iterator I = Map.begin(),
+ E = Map.end(); I != E;++I)
+ if (I->second == CP) {
+ Map.erase(I);
+ return;
+ }
+ }
};
//---- ConstPoolUInt::get() and ConstPoolSInt::get() implementations...
return Result;
}
+// ConstPoolArray::get(const string&) - Return an array that is initialized to
+// contain the specified string. A null terminator is added to the specified
+// string so that it may be used in a natural way...
+//
+ConstPoolArray *ConstPoolArray::get(const string &Str) {
+ vector<ConstPoolVal*> ElementVals;
+
+ for (unsigned i = 0; i < Str.length(); ++i)
+ ElementVals.push_back(ConstPoolUInt::get(Type::UByteTy, Str[i]));
+
+ // Add a null terminator to the string...
+ ElementVals.push_back(ConstPoolUInt::get(Type::UByteTy, 0));
+
+ ArrayType *ATy = ArrayType::get(Type::UByteTy/*,stringConstant.length()*/);
+ return ConstPoolArray::get(ATy, ElementVals);
+}
+
+
+// destroyConstant - Remove the constant from the constant table...
+//
+void ConstPoolArray::destroyConstant() {
+ ArrayConstants.remove(this);
+ destroyConstantImpl();
+}
+
//---- ConstPoolStruct::get() implementation...
//
static ValueMap<vector<ConstPoolVal*>, ConstPoolStruct> StructConstants;
StructConstants.add(Ty, V, Result = new ConstPoolStruct(Ty, V));
return Result;
}
+
+// destroyConstant - Remove the constant from the constant table...
+//
+void ConstPoolStruct::destroyConstant() {
+ StructConstants.remove(this);
+ destroyConstantImpl();
+}
+
+//---- ConstPoolPointerNull::get() implementation...
+//
+static ValueMap<char, ConstPoolPointerNull> NullPtrConstants;
+
+ConstPoolPointerNull *ConstPoolPointerNull::get(const PointerType *Ty) {
+ ConstPoolPointerNull *Result = NullPtrConstants.get(Ty, 0);
+ if (!Result) // If no preexisting value, create one now...
+ NullPtrConstants.add(Ty, 0, Result = new ConstPoolPointerNull(Ty));
+ return Result;
+}
+
+//---- ConstPoolPointerRef::get() implementation...
+//
+ConstPoolPointerRef *ConstPoolPointerRef::get(GlobalValue *GV) {
+ assert(GV->getParent() && "Global Value must be attached to a module!");
+
+ // The Module handles the pointer reference sharing...
+ return GV->getParent()->getConstPoolPointerRef(GV);
+}
+
+
+void ConstPoolPointerRef::mutateReference(GlobalValue *NewGV) {
+ getValue()->getParent()->mutateConstPoolPointerRef(getValue(), NewGV);
+ Operands[0] = NewGV;
+}
projects / oota-llvm.git / blobdiff