RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-22 18:54:02 +01:00
Code Issues Projects Releases Wiki Activity

Revert r134921, 134917, 134908 and 134907. They're causing failures

Browse Source 
in multiple buildbots.

llvm-svn: 134936
This commit is contained in:
Eric Christopher 2011-07-11 23:06:52 +00:00
parent 7c47d39ca1
commit 3dd1f02420
31 changed files with 1001 additions and 1711 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
utils/TableGen/ARMDecoderEmitter.cpp
View File

@ -114,7 +114,7 @@ enum {
/// byteFromBitsInit - Return the byte value from a BitsInit.
/// Called from getByteField().
static uint8_t byteFromBitsInit(const BitsInit &init) {
static uint8_t byteFromBitsInit(BitsInit &init) {
int width = init.getNumBits();
assert(width <= 8 && "Field is too large for uint8_t!");
@ -125,7 +125,7 @@ static uint8_t byteFromBitsInit(const BitsInit &init) {
uint8_t ret = 0;
for (index = 0; index < width; index++) {
if (static_cast<const BitInit*>(init.getBit(index))->getValue())
if (static_cast<BitInit*>(init.getBit(index))->getValue())
ret |= mask;
mask <<= 1;
@ -135,12 +135,12 @@ static uint8_t byteFromBitsInit(const BitsInit &init) {
}
static uint8_t getByteField(const Record &def, const char *str) {
const BitsInit *bits = def.getValueAsBitsInit(str);
BitsInit *bits = def.getValueAsBitsInit(str);
return byteFromBitsInit(*bits);
}
static const BitsInit &getBitsField(const Record &def, const char *str) {
const BitsInit *bits = def.getValueAsBitsInit(str);
static BitsInit &getBitsField(const Record &def, const char *str) {
BitsInit *bits = def.getValueAsBitsInit(str);
return *bits;
}
@ -183,15 +183,15 @@ static bool ValueNotSet(bit_value_t V) {
static int Value(bit_value_t V) {
return ValueNotSet(V) ? -1 : (V == BIT_FALSE ? 0 : 1);
}
static bit_value_t bitFromBits(const BitsInit &bits, unsigned index) {
if (const BitInit *bit = dynamic_cast<const BitInit*>(bits.getBit(index)))
static bit_value_t bitFromBits(BitsInit &bits, unsigned index) {
if (BitInit *bit = dynamic_cast<BitInit*>(bits.getBit(index)))
return bit->getValue() ? BIT_TRUE : BIT_FALSE;
// The bit is uninitialized.
return BIT_UNSET;
}
// Prints the bit value for each position.
static void dumpBits(raw_ostream &o, const BitsInit &bits) {
static void dumpBits(raw_ostream &o, BitsInit &bits) {
unsigned index;
for (index = bits.getNumBits(); index > 0; index--) {
@ -424,8 +424,7 @@ protected:
if (AllInstructions[Opcode]->isPseudo)
return;
const BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef,
"Inst");
BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef, "Inst");
for (unsigned i = 0; i < BIT_WIDTH; ++i)
Insn[i] = bitFromBits(Bits, i);
@ -1559,7 +1558,7 @@ ARMDEBackend::populateInstruction(const CodeGenInstruction &CGI,
const StringRef Name = Def.getName();
uint8_t Form = getByteField(Def, "Form");
const BitsInit &Bits = getBitsField(Def, "Inst");
BitsInit &Bits = getBitsField(Def, "Inst");
// If all the bit positions are not specified; do not decode this instruction.
// We are bound to fail! For proper disassembly, the well-known encoding bits

24
utils/TableGen/AsmMatcherEmitter.cpp
View File

@ -869,7 +869,7 @@ AsmMatcherInfo::getOperandClass(const CGIOperandList::OperandInfo &OI,
int SubOpIdx) {
Record *Rec = OI.Rec;
if (SubOpIdx != -1)
Rec = dynamic_cast<const DefInit*>(OI.MIOperandInfo->getArg(SubOpIdx))->getDef();
Rec = dynamic_cast<DefInit*>(OI.MIOperandInfo->getArg(SubOpIdx))->getDef();
if (Rec->isSubClassOf("RegisterOperand")) {
// RegisterOperand may have an associated ParserMatchClass. If it does,
@ -879,7 +879,7 @@ AsmMatcherInfo::getOperandClass(const CGIOperandList::OperandInfo &OI,
throw "Record `" + Rec->getName() +
"' does not have a ParserMatchClass!\n";
if (const DefInit *DI= dynamic_cast<const DefInit*>(R->getValue())) {
if (DefInit *DI= dynamic_cast<DefInit*>(R->getValue())) {
Record *MatchClass = DI->getDef();
if (ClassInfo *CI = AsmOperandClasses[MatchClass])
return CI;
@ -1046,9 +1046,9 @@ void AsmMatcherInfo::BuildOperandClasses() {
ClassInfo *CI = AsmOperandClasses[*it];
CI->Kind = ClassInfo::UserClass0 + Index;
const ListInit *Supers = (*it)->getValueAsListInit("SuperClasses");
ListInit *Supers = (*it)->getValueAsListInit("SuperClasses");
for (unsigned i = 0, e = Supers->getSize(); i != e; ++i) {
const DefInit *DI = dynamic_cast<const DefInit*>(Supers->getElement(i));
DefInit *DI = dynamic_cast<DefInit*>(Supers->getElement(i));
if (!DI) {
PrintError((*it)->getLoc(), "Invalid super class reference!");
continue;
@ -1065,28 +1065,28 @@ void AsmMatcherInfo::BuildOperandClasses() {
CI->ValueName = (*it)->getName();
// Get or construct the predicate method name.
const Init *PMName = (*it)->getValueInit("PredicateMethod");
if (const StringInit *SI = dynamic_cast<const StringInit*>(PMName)) {
Init *PMName = (*it)->getValueInit("PredicateMethod");
if (StringInit *SI = dynamic_cast<StringInit*>(PMName)) {
CI->PredicateMethod = SI->getValue();
} else {
assert(dynamic_cast<const UnsetInit*>(PMName) &&
assert(dynamic_cast<UnsetInit*>(PMName) &&
"Unexpected PredicateMethod field!");
CI->PredicateMethod = "is" + CI->ClassName;
}
// Get or construct the render method name.
const Init *RMName = (*it)->getValueInit("RenderMethod");
if (const StringInit *SI = dynamic_cast<const StringInit*>(RMName)) {
Init *RMName = (*it)->getValueInit("RenderMethod");
if (StringInit *SI = dynamic_cast<StringInit*>(RMName)) {
CI->RenderMethod = SI->getValue();
} else {
assert(dynamic_cast<const UnsetInit*>(RMName) &&
assert(dynamic_cast<UnsetInit*>(RMName) &&
"Unexpected RenderMethod field!");
CI->RenderMethod = "add" + CI->ClassName + "Operands";
}
// Get the parse method name or leave it as empty.
const Init *PRMName = (*it)->getValueInit("ParserMethod");
if (const StringInit *SI = dynamic_cast<const StringInit*>(PRMName))
Init *PRMName = (*it)->getValueInit("ParserMethod");
if (StringInit *SI = dynamic_cast<StringInit*>(PRMName))
CI->ParserMethod = SI->getValue();
AsmOperandClasses[*it] = CI;

10
utils/TableGen/CallingConvEmitter.cpp
View File

@ -40,7 +40,7 @@ void CallingConvEmitter::run(raw_ostream &O) {
void CallingConvEmitter::EmitCallingConv(Record *CC, raw_ostream &O) {
const ListInit *CCActions = CC->getValueAsListInit("Actions");
ListInit *CCActions = CC->getValueAsListInit("Actions");
Counter = 0;
O << "\n\nstatic bool " << CC->getName()
@ -67,7 +67,7 @@ void CallingConvEmitter::EmitAction(Record *Action,
O << IndentStr << "if (";
if (Action->isSubClassOf("CCIfType")) {
const ListInit *VTs = Action->getValueAsListInit("VTs");
ListInit *VTs = Action->getValueAsListInit("VTs");
for (unsigned i = 0, e = VTs->getSize(); i != e; ++i) {
Record *VT = VTs->getElementAsRecord(i);
if (i != 0) O << " ||\n " << IndentStr;
@ -91,7 +91,7 @@ void CallingConvEmitter::EmitAction(Record *Action,
<< "(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))\n"
<< IndentStr << " return false;\n";
} else if (Action->isSubClassOf("CCAssignToReg")) {
const ListInit *RegList = Action->getValueAsListInit("RegList");
ListInit *RegList = Action->getValueAsListInit("RegList");
if (RegList->getSize() == 1) {
O << IndentStr << "if (unsigned Reg = State.AllocateReg(";
O << getQualifiedName(RegList->getElementAsRecord(0)) << ")) {\n";
@ -112,8 +112,8 @@ void CallingConvEmitter::EmitAction(Record *Action,
O << IndentStr << " return false;\n";
O << IndentStr << "}\n";
} else if (Action->isSubClassOf("CCAssignToRegWithShadow")) {
const ListInit *RegList = Action->getValueAsListInit("RegList");
const ListInit *ShadowRegList = Action->getValueAsListInit("ShadowRegList");
ListInit *RegList = Action->getValueAsListInit("RegList");
ListInit *ShadowRegList = Action->getValueAsListInit("ShadowRegList");
if (ShadowRegList->getSize() >0 &&
ShadowRegList->getSize() != RegList->getSize())
throw "Invalid length of list of shadowed registers";

10
utils/TableGen/ClangAttrEmitter.cpp
View File

@ -21,19 +21,17 @@ using namespace llvm;
static const std::vector<StringRef>
getValueAsListOfStrings(Record &R, StringRef FieldName) {
const ListInit *List = R.getValueAsListInit(FieldName);
ListInit *List = R.getValueAsListInit(FieldName);
assert (List && "Got a null ListInit");
std::vector<StringRef> Strings;
Strings.reserve(List->getSize());
for (ListInit::const_iterator i = List->begin(), e = List->end();
i != e;
++i) {
for (ListInit::iterator i = List->begin(), e = List->end(); i != e; ++i) {
assert(*i && "Got a null element in a ListInit");
if (const StringInit *S = dynamic_cast<const StringInit *>(*i))
if (StringInit *S = dynamic_cast<StringInit *>(*i))
Strings.push_back(S->getValue());
else if (const CodeInit *C = dynamic_cast<const CodeInit *>(*i))
else if (CodeInit *C = dynamic_cast<CodeInit *>(*i))
Strings.push_back(C->getValue());
else
assert(false && "Got a non-string, non-code element in a ListInit");

8
utils/TableGen/ClangDiagnosticsEmitter.cpp
View File

@ -74,8 +74,7 @@ getCategoryFromDiagGroup(const Record *Group,
static std::string getDiagnosticCategory(const Record *R,
DiagGroupParentMap &DiagGroupParents) {
// If the diagnostic is in a group, and that group has a category, use it.
if (const DefInit *Group =
dynamic_cast<const DefInit*>(R->getValueInit("Group"))) {
if (DefInit *Group = dynamic_cast<DefInit*>(R->getValueInit("Group"))) {
// Check the diagnostic's diag group for a category.
std::string CatName = getCategoryFromDiagGroup(Group->getDef(),
DiagGroupParents);
@ -160,8 +159,7 @@ void ClangDiagsDefsEmitter::run(raw_ostream &OS) {
OS.write_escaped(R.getValueAsString("Text")) << '"';
// Warning associated with the diagnostic.
if (const DefInit *DI =
dynamic_cast<const DefInit*>(R.getValueInit("Group"))) {
if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group"))) {
OS << ", \"";
OS.write_escaped(DI->getDef()->getValueAsString("GroupName")) << '"';
} else {
@ -227,7 +225,7 @@ void ClangDiagGroupsEmitter::run(raw_ostream &OS) {
Records.getAllDerivedDefinitions("Diagnostic");
for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
const Record *R = Diags[i];
const DefInit *DI = dynamic_cast<const DefInit*>(R->getValueInit("Group"));
DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("Group"));
if (DI == 0) continue;
std::string GroupName = DI->getDef()->getValueAsString("GroupName");
DiagsInGroup[GroupName].DiagsInGroup.push_back(R);

30
utils/TableGen/ClangSACheckersEmitter.cpp
View File

@ -28,8 +28,7 @@ static bool isHidden(const Record &R) {
if (R.getValueAsBit("Hidden"))
return true;
// Not declared as hidden, check the parent package if it is hidden.
if (const DefInit *DI =
dynamic_cast<const DefInit*>(R.getValueInit("ParentPackage")))
if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("ParentPackage")))
return isHidden(*DI->getDef());
return false;
@ -43,8 +42,7 @@ static std::string getPackageFullName(const Record *R);
static std::string getParentPackageFullName(const Record *R) {
std::string name;
if (const DefInit *DI =
dynamic_cast<const DefInit*>(R->getValueInit("ParentPackage")))
if (DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("ParentPackage")))
name = getPackageFullName(DI->getDef());
return name;
}
@ -65,8 +63,8 @@ static std::string getCheckerFullName(const Record *R) {
}
static std::string getStringValue(const Record &R, StringRef field) {
if (const StringInit *
SI = dynamic_cast<const StringInit*>(R.getValueInit(field)))
if (StringInit *
SI = dynamic_cast<StringInit*>(R.getValueInit(field)))
return SI->getValue();
return std::string();
}
@ -131,8 +129,8 @@ void ClangSACheckersEmitter::run(raw_ostream &OS) {
for (unsigned i = 0, e = checkers.size(); i != e; ++i) {
Record *R = checkers[i];
Record *package = 0;
if (const DefInit *
DI = dynamic_cast<const DefInit*>(R->getValueInit("ParentPackage")))
if (DefInit *
DI = dynamic_cast<DefInit*>(R->getValueInit("ParentPackage")))
package = DI->getDef();
if (!isCheckerNamed(R) && !package)
throw "Checker '" + R->getName() + "' is neither named, nor in a package!";
@ -151,23 +149,21 @@ void ClangSACheckersEmitter::run(raw_ostream &OS) {
Record *currR = isCheckerNamed(R) ? R : package;
// Insert the checker and its parent packages into the subgroups set of
// the corresponding parent package.
while (const DefInit *DI =
dynamic_cast<const DefInit*>(currR->getValueInit("ParentPackage"))) {
while (DefInit *DI
= dynamic_cast<DefInit*>(currR->getValueInit("ParentPackage"))) {
Record *parentPackage = DI->getDef();
recordGroupMap[parentPackage]->SubGroups.insert(currR);
currR = parentPackage;
}
// Insert the checker into the set of its group.
if (const DefInit *DI =
dynamic_cast<const DefInit*>(R->getValueInit("Group")))
if (DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("Group")))
recordGroupMap[DI->getDef()]->Checkers.insert(R);
}
// If a package is in group, add all its checkers and its sub-packages
// checkers into the group.
for (unsigned i = 0, e = packages.size(); i != e; ++i)
if (const DefInit *DI =
dynamic_cast<const DefInit*>(packages[i]->getValueInit("Group")))
if (DefInit *DI = dynamic_cast<DefInit*>(packages[i]->getValueInit("Group")))
addPackageToCheckerGroup(packages[i], DI->getDef(), recordGroupMap);
typedef std::map<std::string, const Record *> SortedRecords;
@ -208,8 +204,7 @@ void ClangSACheckersEmitter::run(raw_ostream &OS) {
OS << "PACKAGE(" << "\"";
OS.write_escaped(getPackageFullName(&R)) << "\", ";
// Group index
if (const DefInit *DI =
dynamic_cast<const DefInit*>(R.getValueInit("Group")))
if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group")))
OS << groupToSortIndex[DI->getDef()] << ", ";
else
OS << "-1, ";
@ -237,8 +232,7 @@ void ClangSACheckersEmitter::run(raw_ostream &OS) {
OS << "\"";
OS.write_escaped(getStringValue(R, "HelpText")) << "\", ";
// Group index
if (const DefInit *DI =
dynamic_cast<const DefInit*>(R.getValueInit("Group")))
if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group")))
OS << groupToSortIndex[DI->getDef()] << ", ";
else
OS << "-1, ";

38
utils/TableGen/CodeEmitterGen.cpp
View File

@ -38,25 +38,21 @@ void CodeEmitterGen::reverseBits(std::vector<Record*> &Insts) {
R->getValueAsBit("isPseudo"))
continue;
const BitsInit *BI = R->getValueAsBitsInit("Inst");
BitsInit *BI = R->getValueAsBitsInit("Inst");
unsigned numBits = BI->getNumBits();
SmallVector<const Init *, 16> NewBits(numBits);
BitsInit *NewBI = new BitsInit(numBits);
for (unsigned bit = 0, end = numBits / 2; bit != end; ++bit) {
unsigned bitSwapIdx = numBits - bit - 1;
const Init *OrigBit = BI->getBit(bit);
const Init *BitSwap = BI->getBit(bitSwapIdx);
NewBits[bit] = BitSwap;
NewBits[bitSwapIdx] = OrigBit;
Init *OrigBit = BI->getBit(bit);
Init *BitSwap = BI->getBit(bitSwapIdx);
NewBI->setBit(bit, BitSwap);
NewBI->setBit(bitSwapIdx, OrigBit);
}
if (numBits % 2) {
unsigned middle = (numBits + 1) / 2;
NewBits[middle] = BI->getBit(middle);
NewBI->setBit(middle, BI->getBit(middle));
}
const BitsInit *NewBI = BitsInit::get(NewBits.begin(), NewBits.end());
// Update the bits in reversed order so that emitInstrOpBits will get the
// correct endianness.
@ -67,14 +63,12 @@ void CodeEmitterGen::reverseBits(std::vector<Record*> &Insts) {
// If the VarBitInit at position 'bit' matches the specified variable then
// return the variable bit position. Otherwise return -1.
int CodeEmitterGen::getVariableBit(const std::string &VarName,
const BitsInit *BI, int bit) {
if (const VarBitInit *VBI =
dynamic_cast<const VarBitInit*>(BI->getBit(bit))) {
if (const VarInit *VI = dynamic_cast<const VarInit*>(VBI->getVariable()))
BitsInit *BI, int bit) {
if (VarBitInit *VBI = dynamic_cast<VarBitInit*>(BI->getBit(bit))) {
if (VarInit *VI = dynamic_cast<VarInit*>(VBI->getVariable()))
if (VI->getName() == VarName)
return VBI->getBitNum();
} else if (const VarInit *VI =
dynamic_cast<const VarInit*>(BI->getBit(bit))) {
} else if (VarInit *VI = dynamic_cast<VarInit*>(BI->getBit(bit))) {
if (VI->getName() == VarName)
return 0;
}
@ -83,8 +77,8 @@ int CodeEmitterGen::getVariableBit(const std::string &VarName,
}
void CodeEmitterGen::
AddCodeToMergeInOperand(Record *R, const BitsInit *BI,
const std::string &VarName, unsigned &NumberedOp,
AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName,
unsigned &NumberedOp,
std::string &Case, CodeGenTarget &Target) {
CodeGenInstruction &CGI = Target.getInstruction(R);
@ -187,7 +181,7 @@ std::string CodeEmitterGen::getInstructionCase(Record *R,
CodeGenTarget &Target) {
std::string Case;
const BitsInit *BI = R->getValueAsBitsInit("Inst");
BitsInit *BI = R->getValueAsBitsInit("Inst");
const std::vector<RecordVal> &Vals = R->getValues();
unsigned NumberedOp = 0;
@ -244,12 +238,12 @@ void CodeEmitterGen::run(raw_ostream &o) {
continue;
}
const BitsInit *BI = R->getValueAsBitsInit("Inst");
BitsInit *BI = R->getValueAsBitsInit("Inst");
// Start by filling in fixed values.
unsigned Value = 0;
for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) {
if (const BitInit *B = dynamic_cast<const BitInit*>(BI->getBit(e-i-1)))
if (BitInit *B = dynamic_cast<BitInit*>(BI->getBit(e-i-1)))
Value |= B->getValue() << (e-i-1);
}
o << " " << Value << "U," << '\t' << "// " << R->getName() << "\n";

6
utils/TableGen/CodeEmitterGen.h
View File

@ -35,11 +35,11 @@ private:
void emitMachineOpEmitter(raw_ostream &o, const std::string &Namespace);
void emitGetValueBit(raw_ostream &o, const std::string &Namespace);
void reverseBits(std::vector<Record*> &Insts);
int getVariableBit(const std::string &VarName, const BitsInit *BI, int bit);
int getVariableBit(const std::string &VarName, BitsInit *BI, int bit);
std::string getInstructionCase(Record *R, CodeGenTarget &Target);
void
AddCodeToMergeInOperand(Record *R, const BitsInit *BI,
const std::string &VarName, unsigned &NumberedOp,
AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName,
unsigned &NumberedOp,
std::string &Case, CodeGenTarget &Target);
};

121
utils/TableGen/CodeGenDAGPatterns.cpp
View File

@ -583,7 +583,7 @@ typedef DepVarMap::const_iterator DepVarMap_citer;
static void FindDepVarsOf(TreePatternNode *N, DepVarMap &DepMap) {
if (N->isLeaf()) {
if (dynamic_cast<const DefInit*>(N->getLeafValue()) != NULL)
if (dynamic_cast<DefInit*>(N->getLeafValue()) != NULL)
DepMap[N->getName()]++;
} else {
for (size_t i = 0, e = N->getNumChildren(); i != e; ++i)
@ -692,7 +692,7 @@ static unsigned getPatternSize(const TreePatternNode *P,
unsigned Size = 3; // The node itself.
// If the root node is a ConstantSDNode, increases its size.
// e.g. (set R32:$dst, 0).
if (P->isLeaf() && dynamic_cast<const IntInit*>(P->getLeafValue()))
if (P->isLeaf() && dynamic_cast<IntInit*>(P->getLeafValue()))
Size += 2;
// FIXME: This is a hack to statically increase the priority of patterns
@ -716,7 +716,7 @@ static unsigned getPatternSize(const TreePatternNode *P,
Child->getType(0) != MVT::Other)
Size += getPatternSize(Child, CGP);
else if (Child->isLeaf()) {
if (dynamic_cast<const IntInit*>(Child->getLeafValue()))
if (dynamic_cast<IntInit*>(Child->getLeafValue()))
Size += 5; // Matches a ConstantSDNode (+3) and a specific value (+2).
else if (Child->getComplexPatternInfo(CGP))
Size += getPatternSize(Child, CGP);
@ -742,8 +742,7 @@ getPatternComplexity(const CodeGenDAGPatterns &CGP) const {
std::string PatternToMatch::getPredicateCheck() const {
std::string PredicateCheck;
for (unsigned i = 0, e = Predicates->getSize(); i != e; ++i) {
if (const DefInit *Pred =
dynamic_cast<const DefInit*>(Predicates->getElement(i))) {
if (DefInit *Pred = dynamic_cast<DefInit*>(Predicates->getElement(i))) {
Record *Def = Pred->getDef();
if (!Def->isSubClassOf("Predicate")) {
#ifndef NDEBUG
@ -867,13 +866,12 @@ bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N,
// The NodeToApply must be a leaf node that is a VT. OtherOperandNum must
// have an integer type that is smaller than the VT.
if (!NodeToApply->isLeaf() ||
!dynamic_cast<const DefInit*>(NodeToApply->getLeafValue()) ||
!static_cast<const DefInit*>(NodeToApply->getLeafValue())->getDef()
!dynamic_cast<DefInit*>(NodeToApply->getLeafValue()) ||
!static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef()
->isSubClassOf("ValueType"))
TP.error(N->getOperator()->getName() + " expects a VT operand!");
MVT::SimpleValueType VT =
getValueType(static_cast<const DefInit*>(NodeToApply->getLeafValue())
->getDef());
getValueType(static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef());
EEVT::TypeSet TypeListTmp(VT, TP);
@ -1023,10 +1021,10 @@ static unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) {
return PFRec->getOnlyTree()->getNumTypes();
// Get the result tree.
const DagInit *Tree = Operator->getValueAsDag("Fragment");
DagInit *Tree = Operator->getValueAsDag("Fragment");
Record *Op = 0;
if (Tree && dynamic_cast<const DefInit*>(Tree->getOperator()))
Op = dynamic_cast<const DefInit*>(Tree->getOperator())->getDef();
if (Tree && dynamic_cast<DefInit*>(Tree->getOperator()))
Op = dynamic_cast<DefInit*>(Tree->getOperator())->getDef();
assert(Op && "Invalid Fragment");
return GetNumNodeResults(Op, CDP);
}
@ -1100,8 +1098,8 @@ bool TreePatternNode::isIsomorphicTo(const TreePatternNode *N,
return false;
if (isLeaf()) {
if (const DefInit *DI = dynamic_cast<const DefInit*>(getLeafValue())) {
if (const DefInit *NDI = dynamic_cast<const DefInit*>(N->getLeafValue())) {
if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) {
if (DefInit *NDI = dynamic_cast<DefInit*>(N->getLeafValue())) {
return ((DI->getDef() == NDI->getDef())
&& (DepVars.find(getName()) == DepVars.end()
|| getName() == N->getName()));
@ -1157,9 +1155,9 @@ SubstituteFormalArguments(std::map<std::string, TreePatternNode*> &ArgMap) {
for (unsigned i = 0, e = getNumChildren(); i != e; ++i) {
TreePatternNode *Child = getChild(i);
if (Child->isLeaf()) {
const Init *Val = Child->getLeafValue();
if (dynamic_cast<const DefInit*>(Val) &&
static_cast<const DefInit*>(Val)->getDef()->getName() == "node") {
Init *Val = Child->getLeafValue();
if (dynamic_cast<DefInit*>(Val) &&
static_cast<DefInit*>(Val)->getDef()->getName() == "node") {
// We found a use of a formal argument, replace it with its value.
TreePatternNode *NewChild = ArgMap[Child->getName()];
assert(NewChild && "Couldn't find formal argument!");
@ -1321,7 +1319,7 @@ getIntrinsicInfo(const CodeGenDAGPatterns &CDP) const {
return 0;
unsigned IID =
dynamic_cast<const IntInit*>(getChild(0)->getLeafValue())->getValue();
dynamic_cast<IntInit*>(getChild(0)->getLeafValue())->getValue();
return &CDP.getIntrinsicInfo(IID);
}
@ -1331,7 +1329,7 @@ const ComplexPattern *
TreePatternNode::getComplexPatternInfo(const CodeGenDAGPatterns &CGP) const {
if (!isLeaf()) return 0;
const DefInit *DI = dynamic_cast<const DefInit*>(getLeafValue());
DefInit *DI = dynamic_cast<DefInit*>(getLeafValue());
if (DI && DI->getDef()->isSubClassOf("ComplexPattern"))
return &CGP.getComplexPattern(DI->getDef());
return 0;
@ -1384,7 +1382,7 @@ TreePatternNode::isCommutativeIntrinsic(const CodeGenDAGPatterns &CDP) const {
bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
CodeGenDAGPatterns &CDP = TP.getDAGPatterns();
if (isLeaf()) {
if (const DefInit *DI = dynamic_cast<const DefInit*>(getLeafValue())) {
if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) {
// If it's a regclass or something else known, include the type.
bool MadeChange = false;
for (unsigned i = 0, e = Types.size(); i != e; ++i)
@ -1393,7 +1391,7 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
return MadeChange;
}
if (const IntInit *II = dynamic_cast<const IntInit*>(getLeafValue())) {
if (IntInit *II = dynamic_cast<IntInit*>(getLeafValue())) {
assert(Types.size() == 1 && "Invalid IntInit");
// Int inits are always integers. :)
@ -1653,7 +1651,7 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
static bool OnlyOnRHSOfCommutative(TreePatternNode *N) {
if (!N->isLeaf() && N->getOperator()->getName() == "imm")
return true;
if (N->isLeaf() && dynamic_cast<const IntInit*>(N->getLeafValue()))
if (N->isLeaf() && dynamic_cast<IntInit*>(N->getLeafValue()))
return true;
return false;
}
@ -1703,14 +1701,14 @@ bool TreePatternNode::canPatternMatch(std::string &Reason,
// TreePattern implementation
//
TreePattern::TreePattern(Record *TheRec, const ListInit *RawPat, bool isInput,
TreePattern::TreePattern(Record *TheRec, ListInit *RawPat, bool isInput,
CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){
isInputPattern = isInput;
for (unsigned i = 0, e = RawPat->getSize(); i != e; ++i)
Trees.push_back(ParseTreePattern(RawPat->getElement(i), ""));
}
TreePattern::TreePattern(Record *TheRec, const DagInit *Pat, bool isInput,
TreePattern::TreePattern(Record *TheRec, DagInit *Pat, bool isInput,
CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){
isInputPattern = isInput;
Trees.push_back(ParseTreePattern(Pat, ""));
@ -1741,17 +1739,16 @@ void TreePattern::ComputeNamedNodes(TreePatternNode *N) {
}
TreePatternNode *TreePattern::ParseTreePattern(const Init *TheInit,
StringRef OpName){
if (const DefInit *DI = dynamic_cast<const DefInit*>(TheInit)) {
TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){
if (DefInit *DI = dynamic_cast<DefInit*>(TheInit)) {
Record *R = DI->getDef();
// Direct reference to a leaf DagNode or PatFrag? Turn it into a
// TreePatternNode of its own. For example:
/// (foo GPR, imm) -> (foo GPR, (imm))
if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag"))
return ParseTreePattern(DagInit::get(DI, "",
std::vector<std::pair<const Init*, std::string> >()),
return ParseTreePattern(new DagInit(DI, "",
std::vector<std::pair<Init*, std::string> >()),
OpName);
// Input argument?
@ -1766,26 +1763,26 @@ TreePatternNode *TreePattern::ParseTreePattern(const Init *TheInit,
return Res;
}
if (const IntInit *II = dynamic_cast<const IntInit*>(TheInit)) {
if (IntInit *II = dynamic_cast<IntInit*>(TheInit)) {
if (!OpName.empty())
error("Constant int argument should not have a name!");
return new TreePatternNode(II, 1);
}
if (const BitsInit *BI = dynamic_cast<const BitsInit*>(TheInit)) {
if (BitsInit *BI = dynamic_cast<BitsInit*>(TheInit)) {
// Turn this into an IntInit.
const Init *II = BI->convertInitializerTo(new IntRecTy());
if (II == 0 || !dynamic_cast<const IntInit*>(II))
Init *II = BI->convertInitializerTo(new IntRecTy());
if (II == 0 || !dynamic_cast<IntInit*>(II))
error("Bits value must be constants!");
return ParseTreePattern(II, OpName);
}
const DagInit *Dag = dynamic_cast<const DagInit*>(TheInit);
DagInit *Dag = dynamic_cast<DagInit*>(TheInit);
if (!Dag) {
TheInit->dump();
error("Pattern has unexpected init kind!");
}
const DefInit *OpDef = dynamic_cast<const DefInit*>(Dag->getOperator());
DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator());
if (!OpDef) error("Pattern has unexpected operator type!");
Record *Operator = OpDef->getDef();
@ -1863,7 +1860,7 @@ TreePatternNode *TreePattern::ParseTreePattern(const Init *TheInit,
else // Otherwise, no chain.
Operator = getDAGPatterns().get_intrinsic_wo_chain_sdnode();
TreePatternNode *IIDNode = new TreePatternNode(IntInit::get(IID), 1);
TreePatternNode *IIDNode = new TreePatternNode(new IntInit(IID), 1);
Children.insert(Children.begin(), IIDNode);
}
@ -1950,8 +1947,7 @@ InferAllTypes(const StringMap<SmallVector<TreePatternNode*,1> > *InNamedTypes) {
// us to match things like:
// def : Pat<(v1i64 (bitconvert(v2i32 DPR:$src))), (v1i64 DPR:$src)>;
if (Nodes[i] == Trees[0] && Nodes[i]->isLeaf()) {
const DefInit *DI =
dynamic_cast<const DefInit*>(Nodes[i]->getLeafValue());
DefInit *DI = dynamic_cast<DefInit*>(Nodes[i]->getLeafValue());
if (DI && (DI->getDef()->isSubClassOf("RegisterClass") ||
DI->getDef()->isSubClassOf("RegisterOperand")))
continue;
@ -2100,7 +2096,7 @@ void CodeGenDAGPatterns::ParsePatternFragments() {
// First step, parse all of the fragments.
for (unsigned i = 0, e = Fragments.size(); i != e; ++i) {
const DagInit *Tree = Fragments[i]->getValueAsDag("Fragment");
DagInit *Tree = Fragments[i]->getValueAsDag("Fragment");
TreePattern *P = new TreePattern(Fragments[i], Tree, true, *this);
PatternFragments[Fragments[i]] = P;
@ -2112,8 +2108,8 @@ void CodeGenDAGPatterns::ParsePatternFragments() {
P->error("Cannot have unnamed 'node' values in pattern fragment!");
// Parse the operands list.
const DagInit *OpsList = Fragments[i]->getValueAsDag("Operands");
const DefInit *OpsOp = dynamic_cast<const DefInit*>(OpsList->getOperator());
DagInit *OpsList = Fragments[i]->getValueAsDag("Operands");
DefInit *OpsOp = dynamic_cast<DefInit*>(OpsList->getOperator());
// Special cases: ops == outs == ins. Different names are used to
// improve readability.
if (!OpsOp ||
@ -2125,8 +2121,8 @@ void CodeGenDAGPatterns::ParsePatternFragments() {
// Copy over the arguments.
Args.clear();
for (unsigned j = 0, e = OpsList->getNumArgs(); j != e; ++j) {
if (!dynamic_cast<const DefInit*>(OpsList->getArg(j)) ||
static_cast<const DefInit*>(OpsList->getArg(j))->
if (!dynamic_cast<DefInit*>(OpsList->getArg(j)) ||
static_cast<DefInit*>(OpsList->getArg(j))->
getDef()->getName() != "node")
P->error("Operands list should all be 'node' values.");
if (OpsList->getArgName(j).empty())
@ -2184,19 +2180,19 @@ void CodeGenDAGPatterns::ParseDefaultOperands() {
// Find some SDNode.
assert(!SDNodes.empty() && "No SDNodes parsed?");
const Init *SomeSDNode = DefInit::get(SDNodes.begin()->first);
Init *SomeSDNode = new DefInit(SDNodes.begin()->first);
for (unsigned iter = 0; iter != 2; ++iter) {
for (unsigned i = 0, e = DefaultOps[iter].size(); i != e; ++i) {
const DagInit *DefaultInfo = DefaultOps[iter][i]->getValueAsDag("DefaultOps");
DagInit *DefaultInfo = DefaultOps[iter][i]->getValueAsDag("DefaultOps");
// Clone the DefaultInfo dag node, changing the operator from 'ops' to
// SomeSDnode so that we can parse this.
std::vector<std::pair<const Init*, std::string> > Ops;
std::vector<std::pair<Init*, std::string> > Ops;
for (unsigned op = 0, e = DefaultInfo->getNumArgs(); op != e; ++op)
Ops.push_back(std::make_pair(DefaultInfo->getArg(op),
DefaultInfo->getArgName(op)));
const DagInit *DI = DagInit::get(SomeSDNode, "", Ops);
DagInit *DI = new DagInit(SomeSDNode, "", Ops);
// Create a TreePattern to parse this.
TreePattern P(DefaultOps[iter][i], DI, false, *this);
@ -2235,7 +2231,7 @@ static bool HandleUse(TreePattern *I, TreePatternNode *Pat,
// No name -> not interesting.
if (Pat->getName().empty()) {
if (Pat->isLeaf()) {
const DefInit *DI = dynamic_cast<const DefInit*>(Pat->getLeafValue());
DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue());
if (DI && (DI->getDef()->isSubClassOf("RegisterClass") ||
DI->getDef()->isSubClassOf("RegisterOperand")))
I->error("Input " + DI->getDef()->getName() + " must be named!");
@ -2245,7 +2241,7 @@ static bool HandleUse(TreePattern *I, TreePatternNode *Pat,
Record *Rec;
if (Pat->isLeaf()) {
const DefInit *DI = dynamic_cast<const DefInit*>(Pat->getLeafValue());
DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue());
if (!DI) I->error("Input $" + Pat->getName() + " must be an identifier!");
Rec = DI->getDef();
} else {
@ -2263,7 +2259,7 @@ static bool HandleUse(TreePattern *I, TreePatternNode *Pat,
}
Record *SlotRec;
if (Slot->isLeaf()) {
SlotRec = dynamic_cast<const DefInit*>(Slot->getLeafValue())->getDef();
SlotRec = dynamic_cast<DefInit*>(Slot->getLeafValue())->getDef();
} else {
assert(Slot->getNumChildren() == 0 && "can't be a use with children!");
SlotRec = Slot->getOperator();
@ -2298,7 +2294,7 @@ FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat,
if (!Dest->isLeaf())
I->error("implicitly defined value should be a register!");
const DefInit *Val = dynamic_cast<const DefInit*>(Dest->getLeafValue());
DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue());
if (!Val || !Val->getDef()->isSubClassOf("Register"))
I->error("implicitly defined value should be a register!");
InstImpResults.push_back(Val->getDef());
@ -2339,7 +2335,7 @@ FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat,
if (!Dest->isLeaf())
I->error("set destination should be a register!");
const DefInit *Val = dynamic_cast<const DefInit*>(Dest->getLeafValue());
DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue());
if (!Val)
I->error("set destination should be a register!");
@ -2405,7 +2401,7 @@ private:
return false;
const TreePatternNode *N0 = N->getChild(0);
if (!N0->isLeaf() || !dynamic_cast<const DefInit*>(N0->getLeafValue()))
if (!N0->isLeaf() || !dynamic_cast<DefInit*>(N0->getLeafValue()))
return false;
const TreePatternNode *N1 = N->getChild(1);
@ -2422,7 +2418,7 @@ private:
void AnalyzeNode(const TreePatternNode *N) {
if (N->isLeaf()) {
if (const DefInit *DI = dynamic_cast<const DefInit*>(N->getLeafValue())) {
if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) {
Record *LeafRec = DI->getDef();
// Handle ComplexPattern leaves.
if (LeafRec->isSubClassOf("ComplexPattern")) {
@ -2529,9 +2525,9 @@ void CodeGenDAGPatterns::ParseInstructions() {
std::vector<Record*> Instrs = Records.getAllDerivedDefinitions("Instruction");
for (unsigned i = 0, e = Instrs.size(); i != e; ++i) {
const ListInit *LI = 0;
ListInit *LI = 0;
if (dynamic_cast<const ListInit*>(Instrs[i]->getValueInit("Pattern")))
if (dynamic_cast<ListInit*>(Instrs[i]->getValueInit("Pattern")))
LI = Instrs[i]->getValueAsListInit("Pattern");
// If there is no pattern, only collect minimal information about the
@ -2623,7 +2619,7 @@ void CodeGenDAGPatterns::ParseInstructions() {
if (i == 0)
Res0Node = RNode;
Record *R = dynamic_cast<const DefInit*>(RNode->getLeafValue())->getDef();
Record *R = dynamic_cast<DefInit*>(RNode->getLeafValue())->getDef();
if (R == 0)
I->error("Operand $" + OpName + " should be a set destination: all "
"outputs must occur before inputs in operand list!");
@ -2668,8 +2664,8 @@ void CodeGenDAGPatterns::ParseInstructions() {
InstInputsCheck.erase(OpName); // It occurred, remove from map.
if (InVal->isLeaf() &&
dynamic_cast<const DefInit*>(InVal->getLeafValue())) {
Record *InRec = static_cast<const DefInit*>(InVal->getLeafValue())->getDef();
dynamic_cast<DefInit*>(InVal->getLeafValue())) {
Record *InRec = static_cast<DefInit*>(InVal->getLeafValue())->getDef();
if (Op.Rec != InRec && !InRec->isSubClassOf("ComplexPattern"))
I->error("Operand $" + OpName + "'s register class disagrees"
" between the operand and pattern");
@ -2869,13 +2865,13 @@ void CodeGenDAGPatterns::ParsePatterns() {
for (unsigned i = 0, e = Patterns.size(); i != e; ++i) {
Record *CurPattern = Patterns[i];
const DagInit *Tree = CurPattern->getValueAsDag("PatternToMatch");
DagInit *Tree = CurPattern->getValueAsDag("PatternToMatch");
TreePattern *Pattern = new TreePattern(CurPattern, Tree, true, *this);
// Inline pattern fragments into it.
Pattern->InlinePatternFragments();
const ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs");
ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs");
if (LI->getSize() == 0) continue; // no pattern.
// Parse the instruction.
@ -3187,8 +3183,7 @@ static void GenerateVariantsOf(TreePatternNode *N,
for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) {
TreePatternNode *Child = N->getChild(i);
if (Child->isLeaf())
if (const DefInit *DI =
dynamic_cast<const DefInit*>(Child->getLeafValue())) {
if (DefInit *DI = dynamic_cast<DefInit*>(Child->getLeafValue())) {
Record *RR = DI->getDef();
if (RR->isSubClassOf("Register"))
continue;

20
utils/TableGen/CodeGenDAGPatterns.h
View File

@ -26,7 +26,7 @@
namespace llvm {
class Record;
class Init;
struct Init;
class ListInit;
class DagInit;
class SDNodeInfo;
@ -306,7 +306,7 @@ class TreePatternNode {
/// Val - The init value (e.g. the "GPRC" record, or "7") for a leaf.
///
const Init *Val;
Init *Val;
/// Name - The name given to this node with the :$foo notation.
///
@ -327,7 +327,7 @@ public:
: Operator(Op), Val(0), TransformFn(0), Children(Ch) {
Types.resize(NumResults);
}
TreePatternNode(const Init *val, unsigned NumResults) // leaf ctor
TreePatternNode(Init *val, unsigned NumResults) // leaf ctor
: Operator(0), Val(val), TransformFn(0) {
Types.resize(NumResults);
}
@ -358,7 +358,7 @@ public:
return Types[ResNo].isDynamicallyResolved();
}
const Init *getLeafValue() const { assert(isLeaf()); return Val; }
Init *getLeafValue() const { assert(isLeaf()); return Val; }
Record *getOperator() const { assert(!isLeaf()); return Operator; }
unsigned getNumChildren() const { return Children.size(); }
@ -517,9 +517,9 @@ public:
/// TreePattern constructor - Parse the specified DagInits into the
/// current record.
TreePattern(Record *TheRec, const ListInit *RawPat, bool isInput,
TreePattern(Record *TheRec, ListInit *RawPat, bool isInput,
CodeGenDAGPatterns &ise);
TreePattern(Record *TheRec, const DagInit *Pat, bool isInput,
TreePattern(Record *TheRec, DagInit *Pat, bool isInput,
CodeGenDAGPatterns &ise);
TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput,
CodeGenDAGPatterns &ise);
@ -576,7 +576,7 @@ public:
void dump() const;
private:
TreePatternNode *ParseTreePattern(const Init *DI, StringRef OpName);
TreePatternNode *ParseTreePattern(Init *DI, StringRef OpName);
void ComputeNamedNodes();
void ComputeNamedNodes(TreePatternNode *N);
};
@ -631,7 +631,7 @@ public:
/// processed to produce isel.
class PatternToMatch {
public:
PatternToMatch(Record *srcrecord, const ListInit *preds,
PatternToMatch(Record *srcrecord, ListInit *preds,
TreePatternNode *src, TreePatternNode *dst,
const std::vector<Record*> &dstregs,
unsigned complexity, unsigned uid)
@ -639,7 +639,7 @@ public:
Dstregs(dstregs), AddedComplexity(complexity), ID(uid) {}
Record *SrcRecord; // Originating Record for the pattern.
const ListInit *Predicates; // Top level predicate conditions to match.
ListInit *Predicates; // Top level predicate conditions to match.
TreePatternNode *SrcPattern; // Source pattern to match.
TreePatternNode *DstPattern; // Resulting pattern.
std::vector<Record*> Dstregs; // Physical register defs being matched.
@ -647,7 +647,7 @@ public:
unsigned ID; // Unique ID for the record.
Record *getSrcRecord() const { return SrcRecord; }
const ListInit *getPredicates() const { return Predicates; }
ListInit *getPredicates() const { return Predicates; }
TreePatternNode *getSrcPattern() const { return SrcPattern; }
TreePatternNode *getDstPattern() const { return DstPattern; }
const std::vector<Record*> &getDstRegs() const { return Dstregs; }

39
utils/TableGen/CodeGenInstruction.cpp
View File

@ -30,10 +30,9 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
hasOptionalDef = false;
isVariadic = false;
const DagInit *OutDI = R->getValueAsDag("OutOperandList");
DagInit *OutDI = R->getValueAsDag("OutOperandList");
if (const DefInit *Init =
dynamic_cast<const DefInit*>(OutDI->getOperator())) {
if (DefInit *Init = dynamic_cast<DefInit*>(OutDI->getOperator())) {
if (Init->getDef()->getName() != "outs")
throw R->getName() + ": invalid def name for output list: use 'outs'";
} else
@ -41,8 +40,8 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
NumDefs = OutDI->getNumArgs();
const DagInit *InDI = R->getValueAsDag("InOperandList");
if (const DefInit *Init = dynamic_cast<const DefInit*>(InDI->getOperator())) {
DagInit *InDI = R->getValueAsDag("InOperandList");
if (DefInit *Init = dynamic_cast<DefInit*>(InDI->getOperator())) {
if (Init->getDef()->getName() != "ins")
throw R->getName() + ": invalid def name for input list: use 'ins'";
} else
@ -51,7 +50,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
unsigned MIOperandNo = 0;
std::set<std::string> OperandNames;
for (unsigned i = 0, e = InDI->getNumArgs()+OutDI->getNumArgs(); i != e; ++i){
const Init *ArgInit;
Init *ArgInit;
std::string ArgName;
if (i < NumDefs) {
ArgInit = OutDI->getArg(i);
@ -61,7 +60,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
ArgName = InDI->getArgName(i-NumDefs);
}
const DefInit *Arg = dynamic_cast<const DefInit*>(ArgInit);
DefInit *Arg = dynamic_cast<DefInit*>(ArgInit);
if (!Arg)
throw "Illegal operand for the '" + R->getName() + "' instruction!";
@ -69,7 +68,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
std::string PrintMethod = "printOperand";
std::string EncoderMethod;
unsigned NumOps = 1;
const DagInit *MIOpInfo = 0;
DagInit *MIOpInfo = 0;
if (Rec->isSubClassOf("RegisterOperand")) {
PrintMethod = Rec->getValueAsString("PrintMethod");
} else if (Rec->isSubClassOf("Operand")) {
@ -79,8 +78,8 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
MIOpInfo = Rec->getValueAsDag("MIOperandInfo");
// Verify that MIOpInfo has an 'ops' root value.
if (!dynamic_cast<const DefInit*>(MIOpInfo->getOperator()) ||
dynamic_cast<const DefInit*>(MIOpInfo->getOperator())
if (!dynamic_cast<DefInit*>(MIOpInfo->getOperator()) ||
dynamic_cast<DefInit*>(MIOpInfo->getOperator())
->getDef()->getName() != "ops")
throw "Bad value for MIOperandInfo in operand '" + Rec->getName() +
"'\n";
@ -179,7 +178,7 @@ CGIOperandList::ParseOperandName(const std::string &Op, bool AllowWholeOp) {
}
// Find the suboperand number involved.
const DagInit *MIOpInfo = OperandList[OpIdx].MIOperandInfo;
DagInit *MIOpInfo = OperandList[OpIdx].MIOperandInfo;
if (MIOpInfo == 0)
throw TheDef->getName() + ": unknown suboperand name in '" + Op + "'";
@ -401,13 +400,12 @@ FlattenAsmStringVariants(StringRef Cur, unsigned Variant) {
/// constructor. It checks if an argument in an InstAlias pattern matches
/// the corresponding operand of the instruction. It returns true on a
/// successful match, with ResOp set to the result operand to be used.
bool CodeGenInstAlias::tryAliasOpMatch(const DagInit *Result,
unsigned AliasOpNo,
bool CodeGenInstAlias::tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo,
Record *InstOpRec, bool hasSubOps,
SMLoc Loc, CodeGenTarget &T,
ResultOperand &ResOp) {
const Init *Arg = Result->getArg(AliasOpNo);
const DefInit *ADI = dynamic_cast<const DefInit*>(Arg);
Init *Arg = Result->getArg(AliasOpNo);
DefInit *ADI = dynamic_cast<DefInit*>(Arg);
if (ADI && ADI->getDef() == InstOpRec) {
// If the operand is a record, it must have a name, and the record type
@ -453,7 +451,7 @@ bool CodeGenInstAlias::tryAliasOpMatch(const DagInit *Result,
return true;
}
if (const IntInit *II = dynamic_cast<const IntInit*>(Arg)) {
if (IntInit *II = dynamic_cast<IntInit*>(Arg)) {
if (hasSubOps || !InstOpRec->isSubClassOf("Operand"))
return false;
// Integer arguments can't have names.
@ -472,7 +470,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
Result = R->getValueAsDag("ResultInst");
// Verify that the root of the result is an instruction.
const DefInit *DI = dynamic_cast<const DefInit*>(Result->getOperator());
DefInit *DI = dynamic_cast<DefInit*>(Result->getOperator());
if (DI == 0 || !DI->getDef()->isSubClassOf("Instruction"))
throw TGError(R->getLoc(), "result of inst alias should be an instruction");
@ -482,7 +480,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
// the same class.
StringMap<Record*> NameClass;
for (unsigned i = 0, e = Result->getNumArgs(); i != e; ++i) {
const DefInit *ADI = dynamic_cast<const DefInit*>(Result->getArg(i));
DefInit *ADI = dynamic_cast<DefInit*>(Result->getArg(i));
if (!ADI || Result->getArgName(i).empty())
continue;
// Verify we don't have something like: (someinst GR16:$foo, GR32:$foo)
@ -521,12 +519,11 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
// If the argument did not match the instruction operand, and the operand
// is composed of multiple suboperands, try matching the suboperands.
if (NumSubOps > 1) {
const DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo;
DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo;
for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) {
if (AliasOpNo >= Result->getNumArgs())
throw TGError(R->getLoc(), "not enough arguments for instruction!");
Record *SubRec =
dynamic_cast<const DefInit*>(MIOI->getArg(SubOp))->getDef();
Record *SubRec = dynamic_cast<DefInit*>(MIOI->getArg(SubOp))->getDef();
if (tryAliasOpMatch(Result, AliasOpNo, SubRec, false,
R->getLoc(), T, ResOp)) {
ResultOperands.push_back(ResOp);

8
utils/TableGen/CodeGenInstruction.h
View File

@ -94,7 +94,7 @@ namespace llvm {
/// MIOperandInfo - Default MI operand type. Note an operand may be made
/// up of multiple MI operands.
const DagInit *MIOperandInfo;
DagInit *MIOperandInfo;
/// Constraint info for this operand. This operand can have pieces, so we
/// track constraint info for each.
@ -102,7 +102,7 @@ namespace llvm {
OperandInfo(Record *R, const std::string &N, const std::string &PMN,
const std::string &EMN, unsigned MION, unsigned MINO,
const DagInit *MIOI)
DagInit *MIOI)
: Rec(R), Name(N), PrinterMethodName(PMN), EncoderMethodName(EMN),
MIOperandNo(MION), MINumOperands(MINO), MIOperandInfo(MIOI) {}
@ -265,7 +265,7 @@ namespace llvm {
std::string AsmString;
/// Result - The result instruction.
const DagInit *Result;
DagInit *Result;
/// ResultInst - The instruction generated by the alias (decoded from
/// Result).
@ -311,7 +311,7 @@ namespace llvm {
CodeGenInstAlias(Record *R, CodeGenTarget &T);
bool tryAliasOpMatch(const DagInit *Result, unsigned AliasOpNo,
bool tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo,
Record *InstOpRec, bool hasSubOps, SMLoc Loc,
CodeGenTarget &T, ResultOperand &ResOp);
};

31
utils/TableGen/CodeGenRegisters.cpp
View File

@ -91,15 +91,14 @@ CodeGenRegister::getSubRegs(CodeGenRegBank &RegBank) {
}
// Process the composites.
const ListInit *Comps = TheDef->getValueAsListInit("CompositeIndices");
ListInit *Comps = TheDef->getValueAsListInit("CompositeIndices");
for (unsigned i = 0, e = Comps->size(); i != e; ++i) {
const DagInit *Pat = dynamic_cast<const DagInit*>(Comps->getElement(i));
DagInit *Pat = dynamic_cast<DagInit*>(Comps->getElement(i));
if (!Pat)
throw TGError(TheDef->getLoc(), "Invalid dag '" +
Comps->getElement(i)->getAsString() +
"' in CompositeIndices");
const DefInit *BaseIdxInit =
dynamic_cast<const DefInit*>(Pat->getOperator());
DefInit *BaseIdxInit = dynamic_cast<DefInit*>(Pat->getOperator());
if (!BaseIdxInit || !BaseIdxInit->getDef()->isSubClassOf("SubRegIndex"))
throw TGError(TheDef->getLoc(), "Invalid SubClassIndex in " +
Pat->getAsString());
@ -108,7 +107,7 @@ CodeGenRegister::getSubRegs(CodeGenRegBank &RegBank) {
CodeGenRegister *R2 = this;
for (DagInit::const_arg_iterator di = Pat->arg_begin(),
de = Pat->arg_end(); di != de; ++di) {
const DefInit *IdxInit = dynamic_cast<const DefInit*>(*di);
DefInit *IdxInit = dynamic_cast<DefInit*>(*di);
if (!IdxInit || !IdxInit->getDef()->isSubClassOf("SubRegIndex"))
throw TGError(TheDef->getLoc(), "Invalid SubClassIndex in " +
Pat->getAsString());
@ -164,7 +163,7 @@ struct TupleExpander : SetTheory::Expander {
void expand(SetTheory &ST, Record *Def, SetTheory::RecSet &Elts) {
std::vector<Record*> Indices = Def->getValueAsListOfDefs("SubRegIndices");
unsigned Dim = Indices.size();
const ListInit *SubRegs = Def->getValueAsListInit("SubRegs");
ListInit *SubRegs = Def->getValueAsListInit("SubRegs");
if (Dim != SubRegs->getSize())
throw TGError(Def->getLoc(), "SubRegIndices and SubRegs size mismatch");
if (Dim < 2)
@ -184,19 +183,19 @@ struct TupleExpander : SetTheory::Expander {
// Precompute some types.
Record *RegisterCl = Def->getRecords().getClass("Register");
RecTy *RegisterRecTy = new RecordRecTy(RegisterCl);
const StringInit *BlankName = StringInit::get("");
StringInit *BlankName = new StringInit("");
// Zip them up.
for (unsigned n = 0; n != Length; ++n) {
std::string Name;
Record *Proto = Lists[0][n];
std::vector<const Init*> Tuple;
std::vector<Init*> Tuple;
unsigned CostPerUse = 0;
for (unsigned i = 0; i != Dim; ++i) {
Record *Reg = Lists[i][n];
if (i) Name += '_';
Name += Reg->getName();
Tuple.push_back(DefInit::get(Reg));
Tuple.push_back(new DefInit(Reg));
CostPerUse = std::max(CostPerUse,
unsigned(Reg->getValueAsInt("CostPerUse")));
}
@ -217,7 +216,7 @@ struct TupleExpander : SetTheory::Expander {
// Replace the sub-register list with Tuple.
if (RV.getName() == "SubRegs")
RV.setValue(ListInit::get(Tuple, RegisterRecTy));
RV.setValue(new ListInit(Tuple, RegisterRecTy));
// Provide a blank AsmName. MC hacks are required anyway.
if (RV.getName() == "AsmName")
@ -225,7 +224,7 @@ struct TupleExpander : SetTheory::Expander {
// CostPerUse is aggregated from all Tuple members.
if (RV.getName() == "CostPerUse")
RV.setValue(IntInit::get(CostPerUse));
RV.setValue(new IntInit(CostPerUse));
// Copy fields from the RegisterTuples def.
if (RV.getName() == "SubRegIndices" ||
@ -279,7 +278,7 @@ CodeGenRegisterClass::CodeGenRegisterClass(CodeGenRegBank &RegBank, Record *R)
Members.insert(RegBank.getReg((*Elements)[i]));
// Alternative allocation orders may be subsets.
const ListInit *Alts = R->getValueAsListInit("AltOrders");
ListInit *Alts = R->getValueAsListInit("AltOrders");
AltOrders.resize(Alts->size());
SetTheory::RecSet Order;
for (unsigned i = 0, e = Alts->size(); i != e; ++i) {
@ -296,11 +295,11 @@ CodeGenRegisterClass::CodeGenRegisterClass(CodeGenRegBank &RegBank, Record *R)
}
// SubRegClasses is a list<dag> containing (RC, subregindex, ...) dags.
const ListInit *SRC = R->getValueAsListInit("SubRegClasses");
ListInit *SRC = R->getValueAsListInit("SubRegClasses");
for (ListInit::const_iterator i = SRC->begin(), e = SRC->end(); i != e; ++i) {
const DagInit *DAG = dynamic_cast<const DagInit*>(*i);
DagInit *DAG = dynamic_cast<DagInit*>(*i);
if (!DAG) throw "SubRegClasses must contain DAGs";
const DefInit *DAGOp = dynamic_cast<const DefInit*>(DAG->getOperator());
DefInit *DAGOp = dynamic_cast<DefInit*>(DAG->getOperator());
Record *RCRec;
if (!DAGOp || !(RCRec = DAGOp->getDef())->isSubClassOf("RegisterClass"))
throw "Operator '" + DAG->getOperator()->getAsString() +
@ -308,7 +307,7 @@ CodeGenRegisterClass::CodeGenRegisterClass(CodeGenRegBank &RegBank, Record *R)
// Iterate over args, all SubRegIndex instances.
for (DagInit::const_arg_iterator ai = DAG->arg_begin(), ae = DAG->arg_end();
ai != ae; ++ai) {
const DefInit *Idx = dynamic_cast<const DefInit*>(*ai);
DefInit *Idx = dynamic_cast<DefInit*>(*ai);
Record *IdxRec;
if (!Idx || !(IdxRec = Idx->getDef())->isSubClassOf("SubRegIndex"))
throw "Argument '" + (*ai)->getAsString() +

4
utils/TableGen/CodeGenTarget.cpp
View File

@ -402,7 +402,7 @@ CodeGenIntrinsic::CodeGenIntrinsic(Record *R) {
// Parse the list of return types.
std::vector<MVT::SimpleValueType> OverloadedVTs;
const ListInit *TypeList = R->getValueAsListInit("RetTypes");
ListInit *TypeList = R->getValueAsListInit("RetTypes");
for (unsigned i = 0, e = TypeList->getSize(); i != e; ++i) {
Record *TyEl = TypeList->getElementAsRecord(i);
assert(TyEl->isSubClassOf("LLVMType") && "Expected a type!");
@ -470,7 +470,7 @@ CodeGenIntrinsic::CodeGenIntrinsic(Record *R) {
}
// Parse the intrinsic properties.
const ListInit *PropList = R->getValueAsListInit("Properties");
ListInit *PropList = R->getValueAsListInit("Properties");
for (unsigned i = 0, e = PropList->getSize(); i != e; ++i) {
Record *Property = PropList->getElementAsRecord(i);
assert(Property->isSubClassOf("IntrinsicProperty") &&

13
utils/TableGen/DAGISelMatcherGen.cpp
View File

@ -203,7 +203,7 @@ void MatcherGen::EmitLeafMatchCode(const TreePatternNode *N) {
assert(N->isLeaf() && "Not a leaf?");
// Direct match against an integer constant.
if (const IntInit *II = dynamic_cast<const IntInit*>(N->getLeafValue())) {
if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) {
// If this is the root of the dag we're matching, we emit a redundant opcode
// check to ensure that this gets folded into the normal top-level
// OpcodeSwitch.
@ -215,7 +215,7 @@ void MatcherGen::EmitLeafMatchCode(const TreePatternNode *N) {
return AddMatcher(new CheckIntegerMatcher(II->getValue()));
}
const DefInit *DI = dynamic_cast<const DefInit*>(N->getLeafValue());
DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue());
if (DI == 0) {
errs() << "Unknown leaf kind: " << *DI << "\n";
abort();
@ -283,8 +283,7 @@ void MatcherGen::EmitOperatorMatchCode(const TreePatternNode *N,
N->getOperator()->getName() == "or") &&
N->getChild(1)->isLeaf() && N->getChild(1)->getPredicateFns().empty() &&
N->getPredicateFns().empty()) {
if (const IntInit *II =
dynamic_cast<const IntInit*>(N->getChild(1)->getLeafValue())) {
if (IntInit *II = dynamic_cast<IntInit*>(N->getChild(1)->getLeafValue())) {
if (!isPowerOf2_32(II->getValue())) { // Don't bother with single bits.
// If this is at the root of the pattern, we emit a redundant
// CheckOpcode so that the following checks get factored properly under
@ -497,7 +496,7 @@ bool MatcherGen::EmitMatcherCode(unsigned Variant) {
--RecNodeEntry; // Entries in VariableMap are biased.
const ComplexPattern &CP =
CGP.getComplexPattern(((const DefInit*)N->getLeafValue())->getDef());
CGP.getComplexPattern(((DefInit*)N->getLeafValue())->getDef());
// Emit a CheckComplexPat operation, which does the match (aborting if it
// fails) and pushes the matched operands onto the recorded nodes list.
@ -573,14 +572,14 @@ void MatcherGen::EmitResultLeafAsOperand(const TreePatternNode *N,
SmallVectorImpl<unsigned> &ResultOps) {
assert(N->isLeaf() && "Must be a leaf");
if (const IntInit *II = dynamic_cast<const IntInit*>(N->getLeafValue())) {
if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) {
AddMatcher(new EmitIntegerMatcher(II->getValue(), N->getType(0)));
ResultOps.push_back(NextRecordedOperandNo++);
return;
}
// If this is an explicit register reference, handle it.
if (const DefInit *DI = dynamic_cast<const DefInit*>(N->getLeafValue())) {
if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) {
Record *Def = DI->getDef();
if (Def->isSubClassOf("Register")) {
const CodeGenRegister *Reg =

8
utils/TableGen/FastISelEmitter.cpp
View File

@ -241,7 +241,7 @@ struct OperandsSignature {
if (Op->getType(0) != VT)
return false;
const DefInit *OpDI = dynamic_cast<const DefInit*>(Op->getLeafValue());
DefInit *OpDI = dynamic_cast<DefInit*>(Op->getLeafValue());
if (!OpDI)
return false;
Record *OpLeafRec = OpDI->getDef();
@ -401,12 +401,12 @@ static std::string PhyRegForNode(TreePatternNode *Op,
if (!Op->isLeaf())
return PhysReg;
const DefInit *OpDI = dynamic_cast<const DefInit*>(Op->getLeafValue());
DefInit *OpDI = dynamic_cast<DefInit*>(Op->getLeafValue());
Record *OpLeafRec = OpDI->getDef();
if (!OpLeafRec->isSubClassOf("Register"))
return PhysReg;
PhysReg += static_cast<const StringInit*>(OpLeafRec->getValue( \
PhysReg += static_cast<StringInit*>(OpLeafRec->getValue( \
"Namespace")->getValue())->getValue();
PhysReg += "::";
PhysReg += Target.getRegBank().getReg(OpLeafRec)->getName();
@ -468,7 +468,7 @@ void FastISelMap::collectPatterns(CodeGenDAGPatterns &CGP) {
// a bit too complicated for now.
if (!Dst->getChild(1)->isLeaf()) continue;
const DefInit *SR = dynamic_cast<const DefInit*>(Dst->getChild(1)->getLeafValue());
DefInit *SR = dynamic_cast<DefInit*>(Dst->getChild(1)->getLeafValue());
if (SR)
SubRegNo = getQualifiedName(SR->getDef());
else

33
utils/TableGen/FixedLenDecoderEmitter.cpp
View File

@ -48,15 +48,15 @@ static bool ValueNotSet(bit_value_t V) {
static int Value(bit_value_t V) {
return ValueNotSet(V) ? -1 : (V == BIT_FALSE ? 0 : 1);
}
static bit_value_t bitFromBits(const BitsInit &bits, unsigned index) {
if (const BitInit *bit = dynamic_cast<const BitInit*>(bits.getBit(index)))
static bit_value_t bitFromBits(BitsInit &bits, unsigned index) {
if (BitInit *bit = dynamic_cast<BitInit*>(bits.getBit(index)))
return bit->getValue() ? BIT_TRUE : BIT_FALSE;
// The bit is uninitialized.
return BIT_UNSET;
}
// Prints the bit value for each position.
static void dumpBits(raw_ostream &o, const BitsInit &bits) {
static void dumpBits(raw_ostream &o, BitsInit &bits) {
unsigned index;
for (index = bits.getNumBits(); index > 0; index--) {
@ -76,8 +76,8 @@ static void dumpBits(raw_ostream &o, const BitsInit &bits) {
}
}
static const BitsInit &getBitsField(const Record &def, const char *str) {
const BitsInit *bits = def.getValueAsBitsInit(str);
static BitsInit &getBitsField(const Record &def, const char *str) {
BitsInit *bits = def.getValueAsBitsInit(str);
return *bits;
}
@ -279,8 +279,7 @@ public:
protected:
// Populates the insn given the uid.
void insnWithID(insn_t &Insn, unsigned Opcode) const {
const BitsInit &Bits =
getBitsField(*AllInstructions[Opcode]->TheDef, "Inst");
BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef, "Inst");
for (unsigned i = 0; i < BIT_WIDTH; ++i)
Insn[i] = bitFromBits(Bits, i);
@ -1231,7 +1230,7 @@ bool FixedLenDecoderEmitter::populateInstruction(const CodeGenInstruction &CGI,
Def.getValueAsBit("isCodeGenOnly"))
return false;
const BitsInit &Bits = getBitsField(Def, "Inst");
BitsInit &Bits = getBitsField(Def, "Inst");
if (Bits.allInComplete()) return false;
std::vector<OperandInfo> InsnOperands;
@ -1252,16 +1251,16 @@ bool FixedLenDecoderEmitter::populateInstruction(const CodeGenInstruction &CGI,
// Gather the outputs/inputs of the instruction, so we can find their
// positions in the encoding. This assumes for now that they appear in the
// MCInst in the order that they're listed.
std::vector<std::pair<const Init*, std::string> > InOutOperands;
const DagInit *Out = Def.getValueAsDag("OutOperandList");
const DagInit *In = Def.getValueAsDag("InOperandList");
std::vector<std::pair<Init*, std::string> > InOutOperands;
DagInit *Out = Def.getValueAsDag("OutOperandList");
DagInit *In = Def.getValueAsDag("InOperandList");
for (unsigned i = 0; i < Out->getNumArgs(); ++i)
InOutOperands.push_back(std::make_pair(Out->getArg(i), Out->getArgName(i)));
for (unsigned i = 0; i < In->getNumArgs(); ++i)
InOutOperands.push_back(std::make_pair(In->getArg(i), In->getArgName(i)));
// For each operand, see if we can figure out where it is encoded.
for (std::vector<std::pair<const Init*, std::string> >::iterator
for (std::vector<std::pair<Init*, std::string> >::iterator
NI = InOutOperands.begin(), NE = InOutOperands.end(); NI != NE; ++NI) {
unsigned PrevBit = ~0;
unsigned Base = ~0;
@ -1269,10 +1268,10 @@ bool FixedLenDecoderEmitter::populateInstruction(const CodeGenInstruction &CGI,
std::string Decoder = "";
for (unsigned bi = 0; bi < Bits.getNumBits(); ++bi) {
const VarBitInit *BI = dynamic_cast<const VarBitInit*>(Bits.getBit(bi));
VarBitInit *BI = dynamic_cast<VarBitInit*>(Bits.getBit(bi));
if (!BI) continue;
const VarInit *Var = dynamic_cast<const VarInit*>(BI->getVariable());
VarInit *Var = dynamic_cast<VarInit*>(BI->getVariable());
assert(Var);
unsigned CurrBit = BI->getBitNum();
if (Var->getName() != NI->second) continue;
@ -1302,7 +1301,7 @@ bool FixedLenDecoderEmitter::populateInstruction(const CodeGenInstruction &CGI,
// for decoding register classes.
// FIXME: This need to be extended to handle instructions with custom
// decoder methods, and operands with (simple) MIOperandInfo's.
const TypedInit *TI = dynamic_cast<const TypedInit*>(NI->first);
TypedInit *TI = dynamic_cast<TypedInit*>(NI->first);
RecordRecTy *Type = dynamic_cast<RecordRecTy*>(TI->getType());
Record *TypeRecord = Type->getRecord();
bool isReg = false;
@ -1314,8 +1313,8 @@ bool FixedLenDecoderEmitter::populateInstruction(const CodeGenInstruction &CGI,
}
RecordVal *DecoderString = TypeRecord->getValue("DecoderMethod");
const StringInit *String = DecoderString ?
dynamic_cast<const StringInit*>(DecoderString->getValue()) :
StringInit *String = DecoderString ?
dynamic_cast<StringInit*>(DecoderString->getValue()) :
0;
if (!isReg && String && String->getValue() != "")
Decoder = String->getValue();

8
utils/TableGen/InstrInfoEmitter.cpp
View File

@ -61,7 +61,7 @@ InstrInfoEmitter::GetOperandInfo(const CodeGenInstruction &Inst) {
// registers in their multi-operand operands. It may also be an anonymous
// operand, which has a single operand, but no declared class for the
// operand.
const DagInit *MIOI = Inst.Operands[i].MIOperandInfo;
DagInit *MIOI = Inst.Operands[i].MIOperandInfo;
if (!MIOI || MIOI->getNumArgs() == 0) {
// Single, anonymous, operand.
@ -70,7 +70,7 @@ InstrInfoEmitter::GetOperandInfo(const CodeGenInstruction &Inst) {
for (unsigned j = 0, e = Inst.Operands[i].MINumOperands; j != e; ++j) {
OperandList.push_back(Inst.Operands[i]);
Record *OpR = dynamic_cast<const DefInit*>(MIOI->getArg(j))->getDef();
Record *OpR = dynamic_cast<DefInit*>(MIOI->getArg(j))->getDef();
OperandList.back().Rec = OpR;
}
}
@ -288,11 +288,11 @@ void InstrInfoEmitter::emitRecord(const CodeGenInstruction &Inst, unsigned Num,
if (Inst.hasExtraDefRegAllocReq) OS << "|(1<<MCID::ExtraDefRegAllocReq)";
// Emit all of the target-specific flags...
const BitsInit *TSF = Inst.TheDef->getValueAsBitsInit("TSFlags");
BitsInit *TSF = Inst.TheDef->getValueAsBitsInit("TSFlags");
if (!TSF) throw "no TSFlags?";
uint64_t Value = 0;
for (unsigned i = 0, e = TSF->getNumBits(); i != e; ++i) {
if (const BitInit *Bit = dynamic_cast<const BitInit*>(TSF->getBit(i)))
if (BitInit *Bit = dynamic_cast<BitInit*>(TSF->getBit(i)))
Value |= uint64_t(Bit->getValue()) << i;
else
throw "Invalid TSFlags bit in " + Inst.TheDef->getName();

46
utils/TableGen/LLVMCConfigurationEmitter.cpp
View File

@ -245,7 +245,7 @@ struct OptionDescription {
unsigned Flags;
std::string Help;
unsigned MultiVal;
const Init* InitVal;
Init* InitVal;
OptionDescription(OptionType::OptionType t = OptionType::Switch,
const std::string& n = "",
@ -589,7 +589,7 @@ Handler GetHandler(FunctionObject* Obj, const DagInit& Dag) {
}
template <class FunctionObject>
void InvokeDagInitHandler(FunctionObject* Obj, const Init* I) {
void InvokeDagInitHandler(FunctionObject* Obj, Init* I) {
typedef void (FunctionObject::*Handler) (const DagInit&);
const DagInit& Dag = InitPtrToDag(I);
@ -658,7 +658,7 @@ public:
/// operator() - Just forwards to the corresponding property
/// handler.
void operator() (const Init* I) {
void operator() (Init* I) {
InvokeDagInitHandler(this, I);
}
@ -705,10 +705,10 @@ private:
void onInit (const DagInit& d) {
CheckNumberOfArguments(d, 1);
const Init* i = d.getArg(0);
Init* i = d.getArg(0);
const std::string& str = i->getAsString();
bool correct = optDesc_.isParameter() && dynamic_cast<const StringInit*>(i);
bool correct = optDesc_.isParameter() && dynamic_cast<StringInit*>(i);
correct |= (optDesc_.isSwitch() && (str == "true" || str == "false"));
if (!correct)
@ -821,7 +821,7 @@ void CollectOptionDescriptions (const RecordVector& V,
for (RecordVector::const_iterator B = V.begin(), E = V.end(); B!=E; ++B)
{
// Throws an exception if the value does not exist.
const ListInit* PropList = (*B)->getValueAsListInit("options");
ListInit* PropList = (*B)->getValueAsListInit("options");
// For every option description in this list: invoke AddOption.
std::for_each(PropList->begin(), PropList->end(), AddOption(OptDescs));
@ -836,8 +836,8 @@ namespace ToolFlags {
struct ToolDescription : public RefCountedBase<ToolDescription> {
std::string Name;
const Init* CmdLine;
const Init* Actions;
Init* CmdLine;
Init* Actions;
StrVector InLanguage;
std::string InFileOption;
std::string OutFileOption;
@ -903,7 +903,7 @@ public:
}
}
void operator() (const Init* I) {
void operator() (Init* I) {
InvokeDagInitHandler(this, I);
}
@ -915,9 +915,9 @@ private:
void onActions (const DagInit& d) {
CheckNumberOfArguments(d, 1);
const Init* Case = d.getArg(0);
Init* Case = d.getArg(0);
if (typeid(*Case) != typeid(DagInit) ||
GetOperatorName(static_cast<const DagInit&>(*Case)) != "case")
GetOperatorName(static_cast<DagInit&>(*Case)) != "case")
throw "The argument to (actions) should be a 'case' construct!";
toolDesc_.Actions = Case;
}
@ -954,7 +954,7 @@ private:
isReallyJoin = true;
}
else {
const Init* I = d.getArg(0);
Init* I = d.getArg(0);
isReallyJoin = InitPtrToBool(I);
}
@ -1007,7 +1007,7 @@ void CollectToolDescriptions (const RecordVector& Tools,
E = Tools.end(); B!=E; ++B) {
const Record* T = *B;
// Throws an exception if the value does not exist.
const ListInit* PropList = T->getValueAsListInit("properties");
ListInit* PropList = T->getValueAsListInit("properties");
IntrusiveRefCntPtr<ToolDescription>
ToolDesc(new ToolDescription(T->getName()));
@ -1163,7 +1163,7 @@ void WalkCase(const Init* Case, F1 TestCallback, F2 StatementCallback,
unsigned i = 1;
for (DagInit::const_arg_iterator B = d.arg_begin(), E = d.arg_end();
B != E; ++B) {
const Init* arg = *B;
Init* arg = *B;
if (!even)
{
@ -1181,8 +1181,8 @@ void WalkCase(const Init* Case, F1 TestCallback, F2 StatementCallback,
}
else
{
if (dynamic_cast<const DagInit*>(arg)
&& GetOperatorName(static_cast<const DagInit&>(*arg)) == "case") {
if (dynamic_cast<DagInit*>(arg)
&& GetOperatorName(static_cast<DagInit&>(*arg)) == "case") {
// Nested 'case'.
WalkCase(arg, TestCallback, StatementCallback, IndentLevel + Indent1);
}
@ -1210,7 +1210,7 @@ class ExtractOptionNames {
ActionName == "parameter_equals" || ActionName == "element_in_list") {
CheckNumberOfArguments(Stmt, 1);
const Init* Arg = Stmt.getArg(0);
Init* Arg = Stmt.getArg(0);
if (typeid(*Arg) == typeid(StringInit))
OptionNames_.insert(InitPtrToString(Arg));
}
@ -1218,7 +1218,7 @@ class ExtractOptionNames {
ActionName == "any_not_empty" || ActionName == "any_empty" ||
ActionName == "not_empty" || ActionName == "empty") {
for (unsigned i = 0, NumArgs = Stmt.getNumArgs(); i < NumArgs; ++i) {
const Init* Arg = Stmt.getArg(i);
Init* Arg = Stmt.getArg(i);
if (typeid(*Arg) == typeid(StringInit))
OptionNames_.insert(InitPtrToString(Arg));
}
@ -2613,7 +2613,7 @@ void EmitPreprocessOptions (const RecordKeeper& Records,
for (RecordVector::const_iterator B = OptionPreprocessors.begin(),
E = OptionPreprocessors.end(); B!=E; ++B) {
const DagInit* Case = (*B)->getValueAsDag("preprocessor");
DagInit* Case = (*B)->getValueAsDag("preprocessor");
EmitCaseConstructHandler(Case, Indent1,
EmitPreprocessOptionsCallback(OptDecs),
false, OptDecs, O);
@ -2645,7 +2645,7 @@ public:
}
}
void operator() (const Init* I) {
void operator() (Init* I) {
InvokeDagInitHandler(this, I);
}
@ -2655,7 +2655,7 @@ private:
CheckNumberOfArguments(d, 2);
const std::string& Lang = InitPtrToString(d.getArg(0));
const Init* Suffixes = d.getArg(1);
Init* Suffixes = d.getArg(1);
// Second argument to lang_to_suffixes is either a single string...
if (typeid(*Suffixes) == typeid(StringInit)) {
@ -2688,7 +2688,7 @@ void EmitPopulateLanguageMap (const RecordKeeper& Records, raw_ostream& O)
// Call DoEmitPopulateLanguageMap.
for (RecordVector::const_iterator B = LangMaps.begin(),
E = LangMaps.end(); B!=E; ++B) {
const ListInit* LangMap = (*B)->getValueAsListInit("map");
ListInit* LangMap = (*B)->getValueAsListInit("map");
std::for_each(LangMap->begin(), LangMap->end(),
DoEmitPopulateLanguageMap(O));
}
@ -2947,7 +2947,7 @@ void FillInHookNames(const ToolDescriptions& ToolDescs,
// Look for hook invocations in 'cmd_line'.
if (!D.CmdLine)
continue;
if (dynamic_cast<const StringInit*>(D.CmdLine))
if (dynamic_cast<StringInit*>(D.CmdLine))
// This is a string.
ExtractHookNames(HookNames, OptDescs).operator()(D.CmdLine);
else

16
utils/TableGen/OptParserEmitter.cpp
View File

@ -56,7 +56,7 @@ static int CompareOptionRecords(const void *Av, const void *Bv) {
static const std::string getOptionName(const Record &R) {
// Use the record name unless EnumName is defined.
if (dynamic_cast<const UnsetInit*>(R.getValueInit("EnumName")))
if (dynamic_cast<UnsetInit*>(R.getValueInit("EnumName")))
return R.getName();
return R.getValueAsString("EnumName");
@ -105,7 +105,7 @@ void OptParserEmitter::run(raw_ostream &OS) {
// The containing option group (if any).
OS << ", ";
if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Group")))
if (const DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group")))
OS << getOptionName(*DI->getDef());
else
OS << "INVALID";
@ -114,7 +114,7 @@ void OptParserEmitter::run(raw_ostream &OS) {
OS << ", INVALID, 0, 0";
// The option help text.
if (!dynamic_cast<const UnsetInit*>(R.getValueInit("HelpText"))) {
if (!dynamic_cast<UnsetInit*>(R.getValueInit("HelpText"))) {
OS << ",\n";
OS << " ";
write_cstring(OS, R.getValueAsString("HelpText"));
@ -145,14 +145,14 @@ void OptParserEmitter::run(raw_ostream &OS) {
// The containing option group (if any).
OS << ", ";
if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Group")))
if (const DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group")))
OS << getOptionName(*DI->getDef());
else
OS << "INVALID";
// The option alias (if any).
OS << ", ";
if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Alias")))
if (const DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Alias")))
OS << getOptionName(*DI->getDef());
else
OS << "INVALID";
@ -166,7 +166,7 @@ void OptParserEmitter::run(raw_ostream &OS) {
for (unsigned i = 0, e = LI->size(); i != e; ++i) {
if (i)
OS << " | ";
OS << dynamic_cast<const DefInit*>(LI->getElement(i))->getDef()->getName();
OS << dynamic_cast<DefInit*>(LI->getElement(i))->getDef()->getName();
}
}
@ -174,7 +174,7 @@ void OptParserEmitter::run(raw_ostream &OS) {
OS << ", " << R.getValueAsInt("NumArgs");
// The option help text.
if (!dynamic_cast<const UnsetInit*>(R.getValueInit("HelpText"))) {
if (!dynamic_cast<UnsetInit*>(R.getValueInit("HelpText"))) {
OS << ",\n";
OS << " ";
write_cstring(OS, R.getValueAsString("HelpText"));
@ -183,7 +183,7 @@ void OptParserEmitter::run(raw_ostream &OS) {
// The option meta-variable name.
OS << ", ";
if (!dynamic_cast<const UnsetInit*>(R.getValueInit("MetaVarName")))
if (!dynamic_cast<UnsetInit*>(R.getValueInit("MetaVarName")))
write_cstring(OS, R.getValueAsString("MetaVarName"));
else
OS << "0";

14
utils/TableGen/PseudoLoweringEmitter.cpp
View File

@ -24,11 +24,11 @@ using namespace llvm;
// a single dag, so we can do fancier things.
unsigned PseudoLoweringEmitter::
addDagOperandMapping(Record *Rec, const DagInit *Dag, CodeGenInstruction &Insn,
addDagOperandMapping(Record *Rec, DagInit *Dag, CodeGenInstruction &Insn,
IndexedMap<OpData> &OperandMap, unsigned BaseIdx) {
unsigned OpsAdded = 0;
for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) {
if (const DefInit *DI = dynamic_cast<const DefInit*>(Dag->getArg(i))) {
if (DefInit *DI = dynamic_cast<DefInit*>(Dag->getArg(i))) {
// Physical register reference. Explicit check for the special case
// "zero_reg" definition.
if (DI->getDef()->isSubClassOf("Register") ||
@ -54,13 +54,11 @@ addDagOperandMapping(Record *Rec, const DagInit *Dag, CodeGenInstruction &Insn,
for (unsigned I = 0, E = Insn.Operands[i].MINumOperands; I != E; ++I)
OperandMap[BaseIdx + i + I].Kind = OpData::Operand;
OpsAdded += Insn.Operands[i].MINumOperands;
} else if (const IntInit *II =
dynamic_cast<const IntInit*>(Dag->getArg(i))) {
} else if (IntInit *II = dynamic_cast<IntInit*>(Dag->getArg(i))) {
OperandMap[BaseIdx + i].Kind = OpData::Imm;
OperandMap[BaseIdx + i].Data.Imm = II->getValue();
++OpsAdded;
} else if (const DagInit *SubDag =
dynamic_cast<const DagInit*>(Dag->getArg(i))) {
} else if (DagInit *SubDag = dynamic_cast<DagInit*>(Dag->getArg(i))) {
// Just add the operands recursively. This is almost certainly
// a constant value for a complex operand (> 1 MI operand).
unsigned NewOps =
@ -79,11 +77,11 @@ void PseudoLoweringEmitter::evaluateExpansion(Record *Rec) {
// Validate that the result pattern has the corrent number and types
// of arguments for the instruction it references.
const DagInit *Dag = Rec->getValueAsDag("ResultInst");
DagInit *Dag = Rec->getValueAsDag("ResultInst");
assert(Dag && "Missing result instruction in pseudo expansion!");
DEBUG(dbgs() << " Result: " << *Dag << "\n");
const DefInit *OpDef = dynamic_cast<const DefInit*>(Dag->getOperator());
DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator());
if (!OpDef)
throw TGError(Rec->getLoc(), Rec->getName() +
" has unexpected operator type!");

2
utils/TableGen/PseudoLoweringEmitter.h
View File

@ -47,7 +47,7 @@ class PseudoLoweringEmitter : public TableGenBackend {
SmallVector<PseudoExpansion, 64> Expansions;
unsigned addDagOperandMapping(Record *Rec, const DagInit *Dag,
unsigned addDagOperandMapping(Record *Rec, DagInit *Dag,
CodeGenInstruction &Insn,
IndexedMap<OpData> &OperandMap,
unsigned BaseIdx);

968
utils/TableGen/Record.cpp
View File

File diff suppressed because it is too large Load Diff

974
utils/TableGen/Record.h
View File

File diff suppressed because it is too large Load Diff

2
utils/TableGen/RegisterInfoEmitter.cpp
View File

@ -722,7 +722,7 @@ RegisterInfoEmitter::runTargetDesc(raw_ostream &OS, CodeGenTarget &Target,
if (!V || !V->getValue())
continue;
const DefInit *DI = dynamic_cast<const DefInit*>(V->getValue());
DefInit *DI = dynamic_cast<DefInit*>(V->getValue());
Record *Alias = DI->getDef();
DwarfRegNums[Reg] = DwarfRegNums[Alias];
}

41
utils/TableGen/SetTheory.cpp
View File

@ -27,14 +27,14 @@ typedef SetTheory::RecVec RecVec;
// (add a, b, ...) Evaluate and union all arguments.
struct AddOp : public SetTheory::Operator {
void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
ST.evaluate(Expr->arg_begin(), Expr->arg_end(), Elts);
}
};
// (sub Add, Sub, ...) Set difference.
struct SubOp : public SetTheory::Operator {
void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
if (Expr->arg_size() < 2)
throw "Set difference needs at least two arguments: " +
Expr->getAsString();
@ -49,7 +49,7 @@ struct SubOp : public SetTheory::Operator {
// (and S1, S2) Set intersection.
struct AndOp : public SetTheory::Operator {
void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
if (Expr->arg_size() != 2)
throw "Set intersection requires two arguments: " + Expr->getAsString();
RecSet S1, S2;
@ -63,16 +63,16 @@ struct AndOp : public SetTheory::Operator {
// SetIntBinOp - Abstract base class for (Op S, N) operators.
struct SetIntBinOp : public SetTheory::Operator {
virtual void apply2(SetTheory &ST, const DagInit *Expr,
virtual void apply2(SetTheory &ST, DagInit *Expr,
RecSet &Set, int64_t N,
RecSet &Elts) =0;
void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
if (Expr->arg_size() != 2)
throw "Operator requires (Op Set, Int) arguments: " + Expr->getAsString();
RecSet Set;
ST.evaluate(Expr->arg_begin()[0], Set);
const IntInit *II = dynamic_cast<const IntInit*>(Expr->arg_begin()[1]);
IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[1]);
if (!II)
throw "Second argument must be an integer: " + Expr->getAsString();
apply2(ST, Expr, Set, II->getValue(), Elts);
@ -81,7 +81,7 @@ struct SetIntBinOp : public SetTheory::Operator {
// (shl S, N) Shift left, remove the first N elements.
struct ShlOp : public SetIntBinOp {
void apply2(SetTheory &ST, const DagInit *Expr,
void apply2(SetTheory &ST, DagInit *Expr,
RecSet &Set, int64_t N,
RecSet &Elts) {
if (N < 0)
@ -93,7 +93,7 @@ struct ShlOp : public SetIntBinOp {
// (trunc S, N) Truncate after the first N elements.
struct TruncOp : public SetIntBinOp {
void apply2(SetTheory &ST, const DagInit *Expr,
void apply2(SetTheory &ST, DagInit *Expr,
RecSet &Set, int64_t N,
RecSet &Elts) {
if (N < 0)
@ -110,7 +110,7 @@ struct RotOp : public SetIntBinOp {
RotOp(bool Rev) : Reverse(Rev) {}
void apply2(SetTheory &ST, const DagInit *Expr,
void apply2(SetTheory &ST, DagInit *Expr,
RecSet &Set, int64_t N,
RecSet &Elts) {
if (Reverse)
@ -129,7 +129,7 @@ struct RotOp : public SetIntBinOp {
// (decimate S, N) Pick every N'th element of S.
struct DecimateOp : public SetIntBinOp {
void apply2(SetTheory &ST, const DagInit *Expr,
void apply2(SetTheory &ST, DagInit *Expr,
RecSet &Set, int64_t N,
RecSet &Elts) {
if (N <= 0)
@ -141,26 +141,25 @@ struct DecimateOp : public SetIntBinOp {
// (sequence "Format", From, To) Generate a sequence of records by name.
struct SequenceOp : public SetTheory::Operator {
void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
if (Expr->arg_size() != 3)
throw "Bad args to (sequence \"Format\", From, To): " +
Expr->getAsString();
std::string Format;
if (const StringInit *SI =
dynamic_cast<const StringInit*>(Expr->arg_begin()[0]))
if (StringInit *SI = dynamic_cast<StringInit*>(Expr->arg_begin()[0]))
Format = SI->getValue();
else
throw "Format must be a string: " + Expr->getAsString();
int64_t From, To;
if (const IntInit *II = dynamic_cast<const IntInit*>(Expr->arg_begin()[1]))
if (IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[1]))
From = II->getValue();
else
throw "From must be an integer: " + Expr->getAsString();
if (From < 0 || From >= (1 << 30))
throw "From out of range";
if (const IntInit *II = dynamic_cast<const IntInit*>(Expr->arg_begin()[2]))
if (IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[2]))
To = II->getValue();
else
throw "From must be an integer: " + Expr->getAsString();
@ -168,7 +167,7 @@ struct SequenceOp : public SetTheory::Operator {
throw "To out of range";
RecordKeeper &Records =
dynamic_cast<const DefInit&>(*Expr->getOperator()).getDef()->getRecords();
dynamic_cast<DefInit&>(*Expr->getOperator()).getDef()->getRecords();
int Step = From <= To ? 1 : -1;
for (To += Step; From != To; From += Step) {
@ -223,9 +222,9 @@ void SetTheory::addFieldExpander(StringRef ClassName, StringRef FieldName) {
addExpander(ClassName, new FieldExpander(FieldName));
}
void SetTheory::evaluate(const Init *Expr, RecSet &Elts) {
void SetTheory::evaluate(Init *Expr, RecSet &Elts) {
// A def in a list can be a just an element, or it may expand.
if (const DefInit *Def = dynamic_cast<const DefInit*>(Expr)) {
if (DefInit *Def = dynamic_cast<DefInit*>(Expr)) {
if (const RecVec *Result = expand(Def->getDef()))
return Elts.insert(Result->begin(), Result->end());
Elts.insert(Def->getDef());
@ -233,14 +232,14 @@ void SetTheory::evaluate(const Init *Expr, RecSet &Elts) {
}
// Lists simply expand.
if (const ListInit *LI = dynamic_cast<const ListInit*>(Expr))
if (ListInit *LI = dynamic_cast<ListInit*>(Expr))
return evaluate(LI->begin(), LI->end(), Elts);
// Anything else must be a DAG.
const DagInit *DagExpr = dynamic_cast<const DagInit*>(Expr);
DagInit *DagExpr = dynamic_cast<DagInit*>(Expr);
if (!DagExpr)
throw "Invalid set element: " + Expr->getAsString();
const DefInit *OpInit = dynamic_cast<const DefInit*>(DagExpr->getOperator());
DefInit *OpInit = dynamic_cast<DefInit*>(DagExpr->getOperator());
if (!OpInit)
throw "Bad set expression: " + Expr->getAsString();
Operator *Op = Operators.lookup(OpInit->getDef()->getName());

6
utils/TableGen/SetTheory.h
View File

@ -55,7 +55,7 @@
namespace llvm {
class DagInit;
class Init;
struct Init;
class Record;
class RecordKeeper;
@ -70,7 +70,7 @@ public:
/// apply - Apply this operator to Expr's arguments and insert the result
/// in Elts.
virtual void apply(SetTheory&, const DagInit *Expr, RecSet &Elts) =0;
virtual void apply(SetTheory&, DagInit *Expr, RecSet &Elts) =0;
};
/// Expander - A callback function that can transform a Record representing a
@ -115,7 +115,7 @@ public:
void addOperator(StringRef Name, Operator*);
/// evaluate - Evaluate Expr and append the resulting set to Elts.
void evaluate(const Init *Expr, RecSet &Elts);
void evaluate(Init *Expr, RecSet &Elts);
/// evaluate - Evaluate a sequence of Inits and append to Elts.
template<typename Iter>

166
utils/TableGen/TGParser.cpp
View File

@ -28,7 +28,7 @@ namespace llvm {
struct SubClassReference {
SMLoc RefLoc;
Record *Rec;
std::vector<const Init*> TemplateArgs;
std::vector<Init*> TemplateArgs;
SubClassReference() : Rec(0) {}
bool isInvalid() const { return Rec == 0; }
@ -37,7 +37,7 @@ struct SubClassReference {
struct SubMultiClassReference {
SMLoc RefLoc;
MultiClass *MC;
std::vector<const Init*> TemplateArgs;
std::vector<Init*> TemplateArgs;
SubMultiClassReference() : MC(0) {}
bool isInvalid() const { return MC == 0; }
@ -50,7 +50,7 @@ void SubMultiClassReference::dump() const {
MC->dump();
errs() << "Template args:\n";
for (std::vector<const Init *>::const_iterator i = TemplateArgs.begin(),
for (std::vector<Init *>::const_iterator i = TemplateArgs.begin(),
iend = TemplateArgs.end();
i != iend;
++i) {
@ -80,7 +80,7 @@ bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
/// SetValue -
/// Return true on error, false on success.
bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName,
const std::vector<unsigned> &BitList, const Init *V) {
const std::vector<unsigned> &BitList, Init *V) {
if (!V) return false;
if (CurRec == 0) CurRec = &CurMultiClass->Rec;
@ -92,7 +92,7 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName,
// Do not allow assignments like 'X = X'. This will just cause infinite loops
// in the resolution machinery.
if (BitList.empty())
if (const VarInit *VI = dynamic_cast<const VarInit*>(V))
if (VarInit *VI = dynamic_cast<VarInit*>(V))
if (VI->getName() == ValName)
return false;
@ -101,37 +101,37 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName,
// initializer.
//
if (!BitList.empty()) {
const BitsInit *CurVal = dynamic_cast<const BitsInit*>(RV->getValue());
BitsInit *CurVal = dynamic_cast<BitsInit*>(RV->getValue());
if (CurVal == 0)
return Error(Loc, "Value '" + ValName + "' is not a bits type");
// Convert the incoming value to a bits type of the appropriate size...
const Init *BI = V->convertInitializerTo(new BitsRecTy(BitList.size()));
Init *BI = V->convertInitializerTo(new BitsRecTy(BitList.size()));
if (BI == 0) {
V->convertInitializerTo(new BitsRecTy(BitList.size()));
return Error(Loc, "Initializer is not compatible with bit range");
}
// We should have a BitsInit type now.
const BitsInit *BInit = dynamic_cast<const BitsInit*>(BI);
BitsInit *BInit = dynamic_cast<BitsInit*>(BI);
assert(BInit != 0);
SmallVector<const Init *, 16> NewBits(CurVal->getNumBits());
BitsInit *NewVal = new BitsInit(CurVal->getNumBits());
// Loop over bits, assigning values as appropriate.
for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
unsigned Bit = BitList[i];
if (NewBits[Bit])
if (NewVal->getBit(Bit))
return Error(Loc, "Cannot set bit #" + utostr(Bit) + " of value '" +
ValName + "' more than once");
NewBits[Bit] = BInit->getBit(i);
NewVal->setBit(Bit, BInit->getBit(i));
}
for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
if (NewBits[i] == 0)
NewBits[i] = CurVal->getBit(i);
if (NewVal->getBit(i) == 0)
NewVal->setBit(i, CurVal->getBit(i));
V = BitsInit::get(NewBits.begin(), NewBits.end());
V = NewVal;
}
if (RV->setValue(V))
@ -633,7 +633,7 @@ RecTy *TGParser::ParseType() {
/// IDValue ::= ID [multiclass template argument]
/// IDValue ::= ID [def name]
///
const Init *TGParser::ParseIDValue(Record *CurRec) {
Init *TGParser::ParseIDValue(Record *CurRec) {
assert(Lex.getCode() == tgtok::Id && "Expected ID in ParseIDValue");
std::string Name = Lex.getCurStrVal();
SMLoc Loc = Lex.getLoc();
@ -643,17 +643,17 @@ const Init *TGParser::ParseIDValue(Record *CurRec) {
/// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID
/// has already been read.
const Init *TGParser::ParseIDValue(Record *CurRec,
Init *TGParser::ParseIDValue(Record *CurRec,
const std::string &Name, SMLoc NameLoc) {
if (CurRec) {
if (const RecordVal *RV = CurRec->getValue(Name))
return VarInit::get(Name, RV->getType());
return new VarInit(Name, RV->getType());
std::string TemplateArgName = CurRec->getName()+":"+Name;
if (CurRec->isTemplateArg(TemplateArgName)) {
const RecordVal *RV = CurRec->getValue(TemplateArgName);
assert(RV && "Template arg doesn't exist??");
return VarInit::get(TemplateArgName, RV->getType());
return new VarInit(TemplateArgName, RV->getType());
}
}
@ -662,12 +662,12 @@ const Init *TGParser::ParseIDValue(Record *CurRec,
if (CurMultiClass->Rec.isTemplateArg(MCName)) {
const RecordVal *RV = CurMultiClass->Rec.getValue(MCName);
assert(RV && "Template arg doesn't exist??");
return VarInit::get(MCName, RV->getType());
return new VarInit(MCName, RV->getType());
}
}
if (Record *D = Records.getDef(Name))
return DefInit::get(D);
return new DefInit(D);
Error(NameLoc, "Variable not defined: '" + Name + "'");
return 0;
@ -677,7 +677,7 @@ const Init *TGParser::ParseIDValue(Record *CurRec,
///
/// Operation ::= XOperator ['<' Type '>'] '(' Args ')'
///
const Init *TGParser::ParseOperation(Record *CurRec) {
Init *TGParser::ParseOperation(Record *CurRec) {
switch (Lex.getCode()) {
default:
TokError("unknown operation");
@ -724,15 +724,15 @@ const Init *TGParser::ParseOperation(Record *CurRec) {
}
Lex.Lex(); // eat the '('
const Init *LHS = ParseValue(CurRec);
Init *LHS = ParseValue(CurRec);
if (LHS == 0) return 0;
if (Code == UnOpInit::HEAD
|| Code == UnOpInit::TAIL
|| Code == UnOpInit::EMPTY) {
const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
const TypedInit *LHSt = dynamic_cast<const TypedInit*>(LHS);
ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS);
if (LHSl == 0 && LHSs == 0 && LHSt == 0) {
TokError("expected list or string type argument in unary operator");
return 0;
@ -758,8 +758,8 @@ const Init *TGParser::ParseOperation(Record *CurRec) {
return 0;
}
if (LHSl) {
const Init *Item = LHSl->getElement(0);
const TypedInit *Itemt = dynamic_cast<const TypedInit*>(Item);
Init *Item = LHSl->getElement(0);
TypedInit *Itemt = dynamic_cast<TypedInit*>(Item);
if (Itemt == 0) {
TokError("untyped list element in unary operator");
return 0;
@ -790,7 +790,7 @@ const Init *TGParser::ParseOperation(Record *CurRec) {
return 0;
}
Lex.Lex(); // eat the ')'
return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec, CurMultiClass);
return (new UnOpInit(Code, LHS, Type))->Fold(CurRec, CurMultiClass);
}
case tgtok::XConcat:
@ -825,7 +825,7 @@ const Init *TGParser::ParseOperation(Record *CurRec) {
}
Lex.Lex(); // eat the '('
SmallVector<const Init*, 2> InitList;
SmallVector<Init*, 2> InitList;
InitList.push_back(ParseValue(CurRec));
if (InitList.back() == 0) return 0;
@ -847,15 +847,15 @@ const Init *TGParser::ParseOperation(Record *CurRec) {
// shorthand for nesting them.
if (Code == BinOpInit::STRCONCAT) {
while (InitList.size() > 2) {
const Init *RHS = InitList.pop_back_val();
RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))
Init *RHS = InitList.pop_back_val();
RHS = (new BinOpInit(Code, InitList.back(), RHS, Type))
->Fold(CurRec, CurMultiClass);
InitList.back() = RHS;
}
}
if (InitList.size() == 2)
return (BinOpInit::get(Code, InitList[0], InitList[1], Type))
return (new BinOpInit(Code, InitList[0], InitList[1], Type))
->Fold(CurRec, CurMultiClass);
Error(OpLoc, "expected two operands to operator");
@ -888,7 +888,7 @@ const Init *TGParser::ParseOperation(Record *CurRec) {
}
Lex.Lex(); // eat the '('
const Init *LHS = ParseValue(CurRec);
Init *LHS = ParseValue(CurRec);
if (LHS == 0) return 0;
if (Lex.getCode() != tgtok::comma) {
@ -897,7 +897,7 @@ const Init *TGParser::ParseOperation(Record *CurRec) {
}
Lex.Lex(); // eat the ','
const Init *MHS = ParseValue(CurRec);
Init *MHS = ParseValue(CurRec);
if (MHS == 0) return 0;
if (Lex.getCode() != tgtok::comma) {
@ -906,7 +906,7 @@ const Init *TGParser::ParseOperation(Record *CurRec) {
}
Lex.Lex(); // eat the ','
const Init *RHS = ParseValue(CurRec);
Init *RHS = ParseValue(CurRec);
if (RHS == 0) return 0;
if (Lex.getCode() != tgtok::r_paren) {
@ -920,23 +920,23 @@ const Init *TGParser::ParseOperation(Record *CurRec) {
case tgtok::XIf: {
// FIXME: The `!if' operator doesn't handle non-TypedInit well at
// all. This can be made much more robust.
const TypedInit *MHSt = dynamic_cast<const TypedInit*>(MHS);
const TypedInit *RHSt = dynamic_cast<const TypedInit*>(RHS);
TypedInit *MHSt = dynamic_cast<TypedInit*>(MHS);
TypedInit *RHSt = dynamic_cast<TypedInit*>(RHS);
RecTy *MHSTy = 0;
RecTy *RHSTy = 0;
if (MHSt == 0 && RHSt == 0) {
const BitsInit *MHSbits = dynamic_cast<const BitsInit*>(MHS);
const BitsInit *RHSbits = dynamic_cast<const BitsInit*>(RHS);
BitsInit *MHSbits = dynamic_cast<BitsInit*>(MHS);
BitsInit *RHSbits = dynamic_cast<BitsInit*>(RHS);
if (MHSbits && RHSbits &&
MHSbits->getNumBits() == RHSbits->getNumBits()) {
Type = new BitRecTy();
break;
} else {
const BitInit *MHSbit = dynamic_cast<const BitInit*>(MHS);
const BitInit *RHSbit = dynamic_cast<const BitInit*>(RHS);
BitInit *MHSbit = dynamic_cast<BitInit*>(MHS);
BitInit *RHSbit = dynamic_cast<BitInit*>(RHS);
if (MHSbit && RHSbit) {
Type = new BitRecTy();
@ -964,7 +964,7 @@ const Init *TGParser::ParseOperation(Record *CurRec) {
break;
}
case tgtok::XForEach: {
const TypedInit *MHSt = dynamic_cast<const TypedInit *>(MHS);
TypedInit *MHSt = dynamic_cast<TypedInit *>(MHS);
if (MHSt == 0) {
TokError("could not get type for !foreach");
return 0;
@ -973,7 +973,7 @@ const Init *TGParser::ParseOperation(Record *CurRec) {
break;
}
case tgtok::XSubst: {
const TypedInit *RHSt = dynamic_cast<const TypedInit *>(RHS);
TypedInit *RHSt = dynamic_cast<TypedInit *>(RHS);
if (RHSt == 0) {
TokError("could not get type for !subst");
return 0;
@ -982,7 +982,7 @@ const Init *TGParser::ParseOperation(Record *CurRec) {
break;
}
}
return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec,
return (new TernOpInit(Code, LHS, MHS, RHS, Type))->Fold(CurRec,
CurMultiClass);
}
}
@ -1038,11 +1038,11 @@ RecTy *TGParser::ParseOperatorType() {
/// SimpleValue ::= SRLTOK '(' Value ',' Value ')'
/// SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')'
///
const Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
const Init *R = 0;
Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
Init *R = 0;
switch (Lex.getCode()) {
default: TokError("Unknown token when parsing a value"); break;
case tgtok::IntVal: R = IntInit::get(Lex.getCurIntVal()); Lex.Lex(); break;
case tgtok::IntVal: R = new IntInit(Lex.getCurIntVal()); Lex.Lex(); break;
case tgtok::StrVal: {
std::string Val = Lex.getCurStrVal();
Lex.Lex();
@ -1053,15 +1053,15 @@ const Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
Lex.Lex();
}
R = StringInit::get(Val);
R = new StringInit(Val);
break;
}
case tgtok::CodeFragment:
R = CodeInit::get(Lex.getCurStrVal());
R = new CodeInit(Lex.getCurStrVal());
Lex.Lex();
break;
case tgtok::question:
R = UnsetInit::get();
R = new UnsetInit();
Lex.Lex();
break;
case tgtok::Id: {
@ -1085,7 +1085,7 @@ const Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
return 0;
}
std::vector<const Init*> ValueList = ParseValueList(CurRec, Class);
std::vector<Init*> ValueList = ParseValueList(CurRec, Class);
if (ValueList.empty()) return 0;
if (Lex.getCode() != tgtok::greater) {
@ -1110,12 +1110,12 @@ const Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
Records.addDef(NewRec);
// The result of the expression is a reference to the new record.
return DefInit::get(NewRec);
return new DefInit(NewRec);
}
case tgtok::l_brace: { // Value ::= '{' ValueList '}'
SMLoc BraceLoc = Lex.getLoc();
Lex.Lex(); // eat the '{'
std::vector<const Init*> Vals;
std::vector<Init*> Vals;
if (Lex.getCode() != tgtok::r_brace) {
Vals = ParseValueList(CurRec);
@ -1127,22 +1127,21 @@ const Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
}
Lex.Lex(); // eat the '}'
SmallVector<const Init *, 16> NewBits(Vals.size());
BitsInit *Result = new BitsInit(Vals.size());
for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
const Init *Bit = Vals[i]->convertInitializerTo(new BitRecTy());
Init *Bit = Vals[i]->convertInitializerTo(new BitRecTy());
if (Bit == 0) {
Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+
") is not convertable to a bit");
return 0;
}
NewBits[Vals.size()-i-1] = Bit;
Result->setBit(Vals.size()-i-1, Bit);
}
return BitsInit::get(NewBits.begin(), NewBits.end());
return Result;
}
case tgtok::l_square: { // Value ::= '[' ValueList ']'
Lex.Lex(); // eat the '['
std::vector<const Init*> Vals;
std::vector<Init*> Vals;
RecTy *DeducedEltTy = 0;
ListRecTy *GivenListTy = 0;
@ -1190,10 +1189,10 @@ const Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
// Check elements
RecTy *EltTy = 0;
for (std::vector<const Init *>::iterator i = Vals.begin(), ie = Vals.end();
for (std::vector<Init *>::iterator i = Vals.begin(), ie = Vals.end();
i != ie;
++i) {
const TypedInit *TArg = dynamic_cast<const TypedInit*>(*i);
TypedInit *TArg = dynamic_cast<TypedInit*>(*i);
if (TArg == 0) {
TokError("Untyped list element");
return 0;
@ -1237,7 +1236,7 @@ const Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
DeducedEltTy = EltTy;
}
return ListInit::get(Vals, DeducedEltTy);
return new ListInit(Vals, DeducedEltTy);
}
case tgtok::l_paren: { // Value ::= '(' IDValue DagArgList ')'
Lex.Lex(); // eat the '('
@ -1246,7 +1245,7 @@ const Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
return 0;
}
const Init *Operator = ParseValue(CurRec);
Init *Operator = ParseValue(CurRec);
if (Operator == 0) return 0;
// If the operator name is present, parse it.
@ -1260,7 +1259,7 @@ const Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
Lex.Lex(); // eat the VarName.
}
std::vector<std::pair<const Init*, std::string> > DagArgs;
std::vector<std::pair<llvm::Init*, std::string> > DagArgs;
if (Lex.getCode() != tgtok::r_paren) {
DagArgs = ParseDagArgList(CurRec);
if (DagArgs.empty()) return 0;
@ -1272,7 +1271,7 @@ const Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
}
Lex.Lex(); // eat the ')'
return DagInit::get(Operator, OperatorName, DagArgs);
return new DagInit(Operator, OperatorName, DagArgs);
}
case tgtok::XHead:
@ -1302,8 +1301,8 @@ const Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
/// ValueSuffix ::= '[' BitList ']'
/// ValueSuffix ::= '.' ID
///
const Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) {
const Init *Result = ParseSimpleValue(CurRec, ItemType);
Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) {
Init *Result = ParseSimpleValue(CurRec, ItemType);
if (Result == 0) return 0;
// Parse the suffixes now if present.
@ -1362,7 +1361,7 @@ const Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) {
Result->getAsString() + "'");
return 0;
}
Result = FieldInit::get(Result, Lex.getCurStrVal());
Result = new FieldInit(Result, Lex.getCurStrVal());
Lex.Lex(); // eat field name
break;
}
@ -1373,20 +1372,20 @@ const Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) {
///
/// ParseDagArgList ::= Value (':' VARNAME)?
/// ParseDagArgList ::= ParseDagArgList ',' Value (':' VARNAME)?
std::vector<std::pair<const Init*, std::string> >
std::vector<std::pair<llvm::Init*, std::string> >
TGParser::ParseDagArgList(Record *CurRec) {
std::vector<std::pair<const Init*, std::string> > Result;
std::vector<std::pair<llvm::Init*, std::string> > Result;
while (1) {
const Init *Val = ParseValue(CurRec);
if (Val == 0) return std::vector<std::pair<const Init*, std::string> >();
Init *Val = ParseValue(CurRec);
if (Val == 0) return std::vector<std::pair<llvm::Init*, std::string> >();
// If the variable name is present, add it.
std::string VarName;
if (Lex.getCode() == tgtok::colon) {
if (Lex.Lex() != tgtok::VarName) { // eat the ':'
TokError("expected variable name in dag literal");
return std::vector<std::pair<const Init*, std::string> >();
return std::vector<std::pair<llvm::Init*, std::string> >();
}
VarName = Lex.getCurStrVal();
Lex.Lex(); // eat the VarName.
@ -1408,10 +1407,9 @@ TGParser::ParseDagArgList(Record *CurRec) {
///
/// ValueList ::= Value (',' Value)
///
std::vector<const Init*> TGParser::ParseValueList(Record *CurRec,
Record *ArgsRec,
RecTy *EltTy) {
std::vector<const Init*> Result;
std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec,
RecTy *EltTy) {
std::vector<Init*> Result;
RecTy *ItemType = EltTy;
unsigned int ArgN = 0;
if (ArgsRec != 0 && EltTy == 0) {
@ -1422,7 +1420,7 @@ std::vector<const Init*> TGParser::ParseValueList(Record *CurRec,
++ArgN;
}
Result.push_back(ParseValue(CurRec, ItemType));
if (Result.back() == 0) return std::vector<const Init*>();
if (Result.back() == 0) return std::vector<Init*>();
while (Lex.getCode() == tgtok::comma) {
Lex.Lex(); // Eat the comma
@ -1431,7 +1429,7 @@ std::vector<const Init*> TGParser::ParseValueList(Record *CurRec,
const std::vector<std::string> &TArgs = ArgsRec->getTemplateArgs();
if (ArgN >= TArgs.size()) {
TokError("too many template arguments");
return std::vector<const Init*>();
return std::vector<Init*>();
}
const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]);
assert(RV && "Template argument record not found??");
@ -1439,7 +1437,7 @@ std::vector<const Init*> TGParser::ParseValueList(Record *CurRec,
++ArgN;
}
Result.push_back(ParseValue(CurRec, ItemType));
if (Result.back() == 0) return std::vector<const Init*>();
if (Result.back() == 0) return std::vector<Init*>();
}
return Result;
@ -1492,7 +1490,7 @@ std::string TGParser::ParseDeclaration(Record *CurRec,
if (Lex.getCode() == tgtok::equal) {
Lex.Lex();
SMLoc ValLoc = Lex.getLoc();
const Init *Val = ParseValue(CurRec, Type);
Init *Val = ParseValue(CurRec, Type);
if (Val == 0 ||
SetValue(CurRec, ValLoc, DeclName, std::vector<unsigned>(), Val))
return "";
@ -1576,7 +1574,7 @@ bool TGParser::ParseBodyItem(Record *CurRec) {
RecTy *Type = Field->getType();
const Init *Val = ParseValue(CurRec, Type);
Init *Val = ParseValue(CurRec, Type);
if (Val == 0) return true;
if (Lex.getCode() != tgtok::semi)
@ -1776,7 +1774,7 @@ std::vector<LetRecord> TGParser::ParseLetList() {
}
Lex.Lex(); // eat the '='.
const Init *Val = ParseValue(0);
Init *Val = ParseValue(0);
if (Val == 0) return std::vector<LetRecord>();
// Now that we have everything, add the record.
@ -1950,7 +1948,7 @@ bool TGParser::ParseDefm(MultiClass *CurMultiClass) {
// template parameters.
MultiClass *MC = MultiClasses[Ref.Rec->getName()];
assert(MC && "Didn't lookup multiclass correctly?");
std::vector<const Init*> &TemplateVals = Ref.TemplateArgs;
std::vector<Init*> &TemplateVals = Ref.TemplateArgs;
// Verify that the correct number of template arguments were specified.
const std::vector<std::string> &TArgs = MC->Rec.getTemplateArgs();

26
utils/TableGen/TGParser.h
View File

@ -25,7 +25,7 @@ namespace llvm {
class RecordVal;
class RecordKeeper;
struct RecTy;
class Init;
struct Init;
struct MultiClass;
struct SubClassReference;
struct SubMultiClassReference;
@ -33,10 +33,10 @@ namespace llvm {
struct LetRecord {
std::string Name;
std::vector<unsigned> Bits;
const Init *Value;
Init *Value;
SMLoc Loc;
LetRecord(const std::string &N, const std::vector<unsigned> &B,
const Init *V, SMLoc L)
LetRecord(const std::string &N, const std::vector<unsigned> &B, Init *V,
SMLoc L)
: Name(N), Bits(B), Value(V), Loc(L) {
}
};
@ -73,7 +73,7 @@ public:
private: // Semantic analysis methods.
bool AddValue(Record *TheRec, SMLoc Loc, const RecordVal &RV);
bool SetValue(Record *TheRec, SMLoc Loc, const std::string &ValName,
const std::vector<unsigned> &BitList, const Init *V);
const std::vector<unsigned> &BitList, Init *V);
bool AddSubClass(Record *Rec, SubClassReference &SubClass);
bool AddSubMultiClass(MultiClass *CurMC,
SubMultiClassReference &SubMultiClass);
@ -98,20 +98,18 @@ private: // Parser methods.
SubClassReference ParseSubClassReference(Record *CurRec, bool isDefm);
SubMultiClassReference ParseSubMultiClassReference(MultiClass *CurMC);
const Init *ParseIDValue(Record *CurRec);
const Init *ParseIDValue(Record *CurRec, const std::string &Name,
SMLoc NameLoc);
const Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = 0);
const Init *ParseValue(Record *CurRec, RecTy *ItemType = 0);
std::vector<const Init*> ParseValueList(Record *CurRec, Record *ArgsRec = 0,
RecTy *EltTy = 0);
std::vector<std::pair<const Init*, std::string> > ParseDagArgList(Record *);
Init *ParseIDValue(Record *CurRec);
Init *ParseIDValue(Record *CurRec, const std::string &Name, SMLoc NameLoc);
Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = 0);
Init *ParseValue(Record *CurRec, RecTy *ItemType = 0);
std::vector<Init*> ParseValueList(Record *CurRec, Record *ArgsRec = 0, RecTy *EltTy = 0);
std::vector<std::pair<llvm::Init*, std::string> > ParseDagArgList(Record *);
bool ParseOptionalRangeList(std::vector<unsigned> &Ranges);
bool ParseOptionalBitList(std::vector<unsigned> &Ranges);
std::vector<unsigned> ParseRangeList();
bool ParseRangePiece(std::vector<unsigned> &Ranges);
RecTy *ParseType();
const Init *ParseOperation(Record *CurRec);
Init *ParseOperation(Record *CurRec);
RecTy *ParseOperatorType();
std::string ParseObjectName();
Record *ParseClassID();

13
utils/TableGen/TableGen.cpp
View File

@ -208,7 +208,6 @@ int main(int argc, char **argv) {
if (error_code ec = MemoryBuffer::getFileOrSTDIN(InputFilename.c_str(), File)) {
errs() << "Could not open input file '" << InputFilename << "': "
<< ec.message() <<"\n";
Init::ReleaseMemory();
return 1;
}
MemoryBuffer *F = File.take();
@ -222,30 +221,25 @@ int main(int argc, char **argv) {
TGParser Parser(SrcMgr, Records);
if (Parser.ParseFile()) {
Init::ReleaseMemory();
if (Parser.ParseFile())
return 1;
}
std::string Error;
tool_output_file Out(OutputFilename.c_str(), Error);
if (!Error.empty()) {
errs() << argv[0] << ": error opening " << OutputFilename
<< ":" << Error << "\n";
Init::ReleaseMemory();
return 1;
}
if (!DependFilename.empty()) {
if (OutputFilename == "-") {
errs() << argv[0] << ": the option -d must be used together with -o\n";
Init::ReleaseMemory();
return 1;
}
tool_output_file DepOut(DependFilename.c_str(), Error);
if (!Error.empty()) {
errs() << argv[0] << ": error opening " << DependFilename
<< ":" << Error << "\n";
Init::ReleaseMemory();
return 1;
}
DepOut.os() << DependFilename << ":";
@ -388,14 +382,11 @@ int main(int argc, char **argv) {
}
default:
assert(1 && "Invalid Action");
Init::ReleaseMemory();
return 1;
}
// Declare success.
Out.keep();
Init::ReleaseMemory();
return 0;
} catch (const TGError &Error) {
@ -408,7 +399,5 @@ int main(int argc, char **argv) {
errs() << argv[0] << ": Unknown unexpected exception occurred.\n";
}
Init::ReleaseMemory();
return 1;
}

6
utils/TableGen/X86RecognizableInstr.cpp
View File

@ -162,7 +162,7 @@ static bool isRegFormat(uint8_t form) {
/// @param init - A reference to the BitsInit to be decoded.
/// @return - The field, with the first bit in the BitsInit as the lowest
/// order bit.
static uint8_t byteFromBitsInit(const BitsInit &init) {
static uint8_t byteFromBitsInit(BitsInit &init) {
int width = init.getNumBits();
assert(width <= 8 && "Field is too large for uint8_t!");
@ -173,7 +173,7 @@ static uint8_t byteFromBitsInit(const BitsInit &init) {
uint8_t ret = 0;
for (index = 0; index < width; index++) {
if (static_cast<const BitInit*>(init.getBit(index))->getValue())
if (static_cast<BitInit*>(init.getBit(index))->getValue())
ret |= mask;
mask <<= 1;
@ -189,7 +189,7 @@ static uint8_t byteFromBitsInit(const BitsInit &init) {
/// @param name - The name of the field in the record.
/// @return - The field, as translated by byteFromBitsInit().
static uint8_t byteFromRec(const Record* rec, const std::string &name) {
const BitsInit* bits = rec->getValueAsBitsInit(name);
BitsInit* bits = rec->getValueAsBitsInit(name);
return byteFromBitsInit(*bits);
}