//===- Record.cpp - Record implementation ---------------------------------===//
-//
+//
// 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.
-//
+//
//===----------------------------------------------------------------------===//
//
//
//===----------------------------------------------------------------------===//
#include "Record.h"
+#include "llvm/Support/DataTypes.h"
+using namespace llvm;
//===----------------------------------------------------------------------===//
// Type implementations
//===----------------------------------------------------------------------===//
-namespace llvm {
-
void RecTy::dump() const { print(std::cerr); }
Init *BitRecTy::convertValue(BitsInit *BI) {
Init *BitRecTy::convertValue(IntInit *II) {
int Val = II->getValue();
if (Val != 0 && Val != 1) return 0; // Only accept 0 or 1 for a bit!
-
- return new BitInit(Val != 0);
+
+ return new BitInit(Val != 0);
}
Init *BitRecTy::convertValue(TypedInit *VI) {
if (Value & ~((1LL << Size)-1))
return 0;
} else {
- if ((Value >> Size) != -1 || ((Value & (1 << Size-1)) == 0))
+ if ((Value >> Size) != -1 || ((Value & (1 << (Size-1))) == 0))
return 0;
}
if (BRT->Size == Size) {
BitsInit *Ret = new BitsInit(Size);
for (unsigned i = 0; i != Size; ++i)
- Ret->setBit(i, new VarBitInit(VI, i));
+ Ret->setBit(i, new VarBitInit(VI, i));
return Ret;
}
if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType())) {
Ret->setBit(0, VI);
return Ret;
}
-
+
return 0;
}
Init *IntRecTy::convertValue(BitsInit *BI) {
int Result = 0;
- for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
+ for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) {
Result |= Bit->getValue() << i;
} else {
bool BitsInit::printInHex(std::ostream &OS) const {
// First, attempt to convert the value into an integer value...
int Result = 0;
- for (unsigned i = 0, e = getNumBits(); i != e; ++i)
+ for (unsigned i = 0, e = getNumBits(); i != e; ++i)
if (BitInit *Bit = dynamic_cast<BitInit*>(getBit(i))) {
Result |= Bit->getValue() << i;
} else {
}
bool BitsInit::printAsUnset(std::ostream &OS) const {
- for (unsigned i = 0, e = getNumBits(); i != e; ++i)
+ for (unsigned i = 0, e = getNumBits(); i != e; ++i)
if (!dynamic_cast<UnsetInit*>(getBit(i)))
return true;
OS << "?";
// resolveReferences - If there are any field references that refer to fields
// that have been filled in, we can propagate the values now.
//
-Init *BitsInit::resolveReferences(Record &R) {
+Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) {
bool Changed = false;
BitsInit *New = new BitsInit(getNumBits());
do {
B = CurBit;
- CurBit = CurBit->resolveReferences(R);
+ CurBit = CurBit->resolveReferences(R, RV);
Changed |= B != CurBit;
} while (B != CurBit);
New->setBit(i, CurBit);
return this;
}
+Init *IntInit::getBinaryOp(BinaryOp Op, Init *RHS) {
+ IntInit *RHSi = dynamic_cast<IntInit*>(RHS);
+ if (RHSi == 0) return 0;
+
+ int NewValue;
+ switch (Op) {
+ default: assert(0 && "Unknown binop");
+ case SHL: NewValue = Value << RHSi->getValue(); break;
+ case SRA: NewValue = Value >> RHSi->getValue(); break;
+ case SRL: NewValue = (unsigned)Value >> (unsigned)RHSi->getValue(); break;
+ }
+ return new IntInit(NewValue);
+}
+
+
Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
BitsInit *BI = new BitsInit(Bits.size());
return new ListInit(Vals);
}
-Init *ListInit::resolveReferences(Record &R) {
+Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) {
std::vector<Init*> Resolved;
Resolved.reserve(getSize());
bool Changed = false;
do {
E = CurElt;
- CurElt = CurElt->resolveReferences(R);
+ CurElt = CurElt->resolveReferences(R, RV);
Changed |= E != CurElt;
} while (E != CurElt);
Resolved.push_back(E);
}
-Init *VarInit::resolveBitReference(Record &R, unsigned Bit) {
- if (R.isTemplateArg(getName()))
- return 0;
+Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV,
+ unsigned Bit) {
+ if (R.isTemplateArg(getName())) return 0;
+ if (IRV && IRV->getName() != getName()) return 0;
RecordVal *RV = R.getValue(getName());
assert(RV && "Reference to a non-existant variable?");
assert(dynamic_cast<BitsInit*>(RV->getValue()));
BitsInit *BI = (BitsInit*)RV->getValue();
-
+
assert(Bit < BI->getNumBits() && "Bit reference out of range!");
Init *B = BI->getBit(Bit);
return 0;
}
-Init *VarInit::resolveListElementReference(Record &R, unsigned Elt) {
- if (R.isTemplateArg(getName()))
- return 0;
+Init *VarInit::resolveListElementReference(Record &R, const RecordVal *IRV,
+ unsigned Elt) {
+ if (R.isTemplateArg(getName())) return 0;
+ if (IRV && IRV->getName() != getName()) return 0;
RecordVal *RV = R.getValue(getName());
assert(RV && "Reference to a non-existant variable?");
/// If a value is set for the variable later, this method will be called on
/// users of the value to allow the value to propagate out.
///
-Init *VarInit::resolveReferences(Record &R) {
+Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) {
if (RecordVal *Val = R.getValue(VarName))
- if (!dynamic_cast<UnsetInit*>(Val->getValue()))
+ if (RV == Val || (RV == 0 && !dynamic_cast<UnsetInit*>(Val->getValue())))
return Val->getValue();
return this;
}
-
-Init *VarBitInit::resolveReferences(Record &R) {
- if (Init *I = getVariable()->resolveBitReference(R, getBitNum()))
+
+Init *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) {
+ if (Init *I = getVariable()->resolveBitReference(R, RV, getBitNum()))
return I;
return this;
}
-Init *VarListElementInit::resolveReferences(Record &R) {
- if (Init *I = getVariable()->resolveListElementReference(R, getElementNum()))
+Init *VarListElementInit::resolveReferences(Record &R, const RecordVal *RV) {
+ if (Init *I = getVariable()->resolveListElementReference(R, RV,
+ getElementNum()))
return I;
return this;
}
-Init *VarListElementInit::resolveBitReference(Record &R, unsigned Bit) {
+Init *VarListElementInit::resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) {
// FIXME: This should be implemented, to support references like:
// bit B = AA[0]{1};
return 0;
}
-Init *VarListElementInit::resolveListElementReference(Record &R, unsigned Elt) {
+Init *VarListElementInit::
+resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) {
// FIXME: This should be implemented, to support references like:
// int B = AA[0][1];
return 0;
OS << Def->getName();
}
-Init *FieldInit::resolveBitReference(Record &R, unsigned Bit) {
+Init *FieldInit::resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) {
if (Init *BitsVal = Rec->getFieldInit(R, FieldName))
if (BitsInit *BI = dynamic_cast<BitsInit*>(BitsVal)) {
assert(Bit < BI->getNumBits() && "Bit reference out of range!");
Init *B = BI->getBit(Bit);
-
+
if (dynamic_cast<BitInit*>(B)) // If the bit is set...
return B; // Replace the VarBitInit with it.
}
return 0;
}
-Init *FieldInit::resolveListElementReference(Record &R, unsigned Elt) {
+Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) {
if (Init *ListVal = Rec->getFieldInit(R, FieldName))
if (ListInit *LI = dynamic_cast<ListInit*>(ListVal)) {
if (Elt >= LI->getSize()) return 0;
return 0;
}
-Init *FieldInit::resolveReferences(Record &R) {
- Init *BitsVal = Rec->getFieldInit(R, FieldName);
+Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) {
+ Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec;
+
+ Init *BitsVal = NewRec->getFieldInit(R, FieldName);
if (BitsVal) {
- Init *BVR = BitsVal->resolveReferences(R);
+ Init *BVR = BitsVal->resolveReferences(R, RV);
return BVR->isComplete() ? BVR : this;
}
+
+ if (NewRec != Rec) {
+ dump();
+ NewRec->dump(); std::cerr << "\n";
+ return new FieldInit(NewRec, FieldName);
+ }
return this;
}
void RecordVal::print(std::ostream &OS, bool PrintSem) const {
if (getPrefix()) OS << "field ";
OS << *getType() << " " << getName();
- if (getValue()) {
+
+ if (getValue())
OS << " = " << *getValue();
- }
+
if (PrintSem) OS << ";\n";
}
-// resolveReferences - If there are any field references that refer to fields
-// that have been filled in, we can propagate the values now.
-//
-void Record::resolveReferences() {
- for (unsigned i = 0, e = Values.size(); i != e; ++i)
- Values[i].setValue(Values[i].getValue()->resolveReferences(*this));
+void Record::setName(const std::string &Name) {
+ if (Records.getDef(getName()) == this) {
+ Records.removeDef(getName());
+ this->Name = Name;
+ Records.addDef(this);
+ } else {
+ Records.removeClass(getName());
+ this->Name = Name;
+ Records.addClass(this);
+ }
+}
+
+/// resolveReferencesTo - If anything in this record refers to RV, replace the
+/// reference to RV with the RHS of RV. If RV is null, we resolve all possible
+/// references.
+void Record::resolveReferencesTo(const RecordVal *RV) {
+ for (unsigned i = 0, e = Values.size(); i != e; ++i) {
+ if (Init *V = Values[i].getValue())
+ Values[i].setValue(V->resolveReferences(*this, RV));
+ }
}
+
void Record::dump() const { std::cerr << *this; }
-std::ostream &operator<<(std::ostream &OS, const Record &R) {
+std::ostream &llvm::operator<<(std::ostream &OS, const Record &R) {
OS << R.getName();
const std::vector<std::string> &TArgs = R.getTemplateArgs();
Init *Record::getValueInit(const std::string &FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
- throw "Record '" + getName() + "' does not have a field named '" +
- FieldName + "!\n";
+ throw "Record `" + getName() + "' does not have a field named `" +
+ FieldName + "'!\n";
return R->getValue();
}
std::string Record::getValueAsString(const std::string &FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
- throw "Record '" + getName() + "' does not have a field named '" +
- FieldName + "!\n";
+ throw "Record `" + getName() + "' does not have a field named `" +
+ FieldName + "'!\n";
if (const StringInit *SI = dynamic_cast<const StringInit*>(R->getValue()))
return SI->getValue();
- throw "Record '" + getName() + "', field '" + FieldName +
+ throw "Record `" + getName() + "', field `" + FieldName +
"' does not have a string initializer!";
}
BitsInit *Record::getValueAsBitsInit(const std::string &FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
- throw "Record '" + getName() + "' does not have a field named '" +
- FieldName + "!\n";
+ throw "Record `" + getName() + "' does not have a field named `" +
+ FieldName + "'!\n";
if (BitsInit *BI = dynamic_cast<BitsInit*>(R->getValue()))
return BI;
- throw "Record '" + getName() + "', field '" + FieldName +
+ throw "Record `" + getName() + "', field `" + FieldName +
"' does not have a BitsInit initializer!";
}
ListInit *Record::getValueAsListInit(const std::string &FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
- throw "Record '" + getName() + "' does not have a field named '" +
- FieldName + "!\n";
+ throw "Record `" + getName() + "' does not have a field named `" +
+ FieldName + "'!\n";
if (ListInit *LI = dynamic_cast<ListInit*>(R->getValue()))
return LI;
- throw "Record '" + getName() + "', field '" + FieldName +
+ throw "Record `" + getName() + "', field `" + FieldName +
"' does not have a list initializer!";
}
int Record::getValueAsInt(const std::string &FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
- throw "Record '" + getName() + "' does not have a field named '" +
- FieldName + "!\n";
+ throw "Record `" + getName() + "' does not have a field named `" +
+ FieldName + "'!\n";
if (IntInit *II = dynamic_cast<IntInit*>(R->getValue()))
return II->getValue();
- throw "Record '" + getName() + "', field '" + FieldName +
+ throw "Record `" + getName() + "', field `" + FieldName +
"' does not have a list initializer!";
}
Record *Record::getValueAsDef(const std::string &FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
- throw "Record '" + getName() + "' does not have a field named '" +
- FieldName + "!\n";
+ throw "Record `" + getName() + "' does not have a field named `" +
+ FieldName + "'!\n";
if (DefInit *DI = dynamic_cast<DefInit*>(R->getValue()))
return DI->getDef();
- throw "Record '" + getName() + "', field '" + FieldName +
+ throw "Record `" + getName() + "', field `" + FieldName +
"' does not have a list initializer!";
}
bool Record::getValueAsBit(const std::string &FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
- throw "Record '" + getName() + "' does not have a field named '" +
- FieldName + "!\n";
+ throw "Record `" + getName() + "' does not have a field named `" +
+ FieldName + "'!\n";
if (BitInit *BI = dynamic_cast<BitInit*>(R->getValue()))
return BI->getValue();
- throw "Record '" + getName() + "', field '" + FieldName +
+ throw "Record `" + getName() + "', field `" + FieldName +
"' does not have a bit initializer!";
}
DagInit *Record::getValueAsDag(const std::string &FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
- throw "Record '" + getName() + "' does not have a field named '" +
- FieldName + "!\n";
+ throw "Record `" + getName() + "' does not have a field named `" +
+ FieldName + "'!\n";
if (DagInit *DI = dynamic_cast<DagInit*>(R->getValue()))
return DI;
- throw "Record '" + getName() + "', field '" + FieldName +
+ throw "Record `" + getName() + "', field `" + FieldName +
"' does not have a dag initializer!";
}
+std::string Record::getValueAsCode(const std::string &FieldName) const {
+ const RecordVal *R = getValue(FieldName);
+ if (R == 0 || R->getValue() == 0)
+ throw "Record `" + getName() + "' does not have a field named `" +
+ FieldName + "'!\n";
+
+ if (const CodeInit *CI = dynamic_cast<const CodeInit*>(R->getValue()))
+ return CI->getValue();
+ throw "Record `" + getName() + "', field `" + FieldName +
+ "' does not have a code initializer!";
+}
+
void RecordKeeper::dump() const { std::cerr << *this; }
-std::ostream &operator<<(std::ostream &OS, const RecordKeeper &RK) {
+std::ostream &llvm::operator<<(std::ostream &OS, const RecordKeeper &RK) {
OS << "------------- Classes -----------------\n";
const std::map<std::string, Record*> &Classes = RK.getClasses();
for (std::map<std::string, Record*>::const_iterator I = Classes.begin(),
- E = Classes.end(); I != E; ++I)
+ E = Classes.end(); I != E; ++I)
OS << "class " << *I->second;
-
+
OS << "------------- Defs -----------------\n";
const std::map<std::string, Record*> &Defs = RK.getDefs();
for (std::map<std::string, Record*>::const_iterator I = Defs.begin(),
- E = Defs.end(); I != E; ++I)
+ E = Defs.end(); I != E; ++I)
OS << "def " << *I->second;
return OS;
}
RecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const {
Record *Class = Records.getClass(ClassName);
if (!Class)
- throw "ERROR: Couldn't find the '" + ClassName + "' class!\n";
+ throw "ERROR: Couldn't find the `" + ClassName + "' class!\n";
std::vector<Record*> Defs;
for (std::map<std::string, Record*>::const_iterator I = getDefs().begin(),
return Defs;
}
-} // End llvm namespace
projects / oota-llvm.git / blobdiff