[llvm-commits] [llvm] r136531 - /llvm/trunk/utils/TableGen/
David Greene
greened at obbligato.org
Fri Jul 29 15:43:06 PDT 2011
Author: greened
Date: Fri Jul 29 17:43:06 2011
New Revision: 136531
URL: http://llvm.org/viewvc/llvm-project?rev=136531&view=rev
Log:
Unconstify Inits
Remove const qualifiers from Init references, per Chris' request.
Modified:
llvm/trunk/utils/TableGen/ARMDecoderEmitter.cpp
llvm/trunk/utils/TableGen/AsmMatcherEmitter.cpp
llvm/trunk/utils/TableGen/CallingConvEmitter.cpp
llvm/trunk/utils/TableGen/ClangAttrEmitter.cpp
llvm/trunk/utils/TableGen/ClangDiagnosticsEmitter.cpp
llvm/trunk/utils/TableGen/ClangSACheckersEmitter.cpp
llvm/trunk/utils/TableGen/CodeEmitterGen.cpp
llvm/trunk/utils/TableGen/CodeEmitterGen.h
llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp
llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h
llvm/trunk/utils/TableGen/CodeGenInstruction.cpp
llvm/trunk/utils/TableGen/CodeGenInstruction.h
llvm/trunk/utils/TableGen/CodeGenRegisters.cpp
llvm/trunk/utils/TableGen/CodeGenTarget.cpp
llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp
llvm/trunk/utils/TableGen/FastISelEmitter.cpp
llvm/trunk/utils/TableGen/FixedLenDecoderEmitter.cpp
llvm/trunk/utils/TableGen/InstrInfoEmitter.cpp
llvm/trunk/utils/TableGen/LLVMCConfigurationEmitter.cpp
llvm/trunk/utils/TableGen/OptParserEmitter.cpp
llvm/trunk/utils/TableGen/PseudoLoweringEmitter.cpp
llvm/trunk/utils/TableGen/PseudoLoweringEmitter.h
llvm/trunk/utils/TableGen/Record.cpp
llvm/trunk/utils/TableGen/Record.h
llvm/trunk/utils/TableGen/RegisterInfoEmitter.cpp
llvm/trunk/utils/TableGen/SetTheory.cpp
llvm/trunk/utils/TableGen/SetTheory.h
llvm/trunk/utils/TableGen/TGParser.cpp
llvm/trunk/utils/TableGen/TGParser.h
llvm/trunk/utils/TableGen/X86RecognizableInstr.cpp
Modified: llvm/trunk/utils/TableGen/ARMDecoderEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/ARMDecoderEmitter.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/ARMDecoderEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/ARMDecoderEmitter.cpp Fri Jul 29 17:43:06 2011
@@ -115,7 +115,7 @@
/// 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!");
@@ -126,7 +126,7 @@
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;
@@ -136,12 +136,12 @@
}
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;
}
@@ -184,15 +184,15 @@
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--) {
@@ -425,7 +425,7 @@
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 +1559,7 @@
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
Modified: llvm/trunk/utils/TableGen/AsmMatcherEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/AsmMatcherEmitter.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/AsmMatcherEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/AsmMatcherEmitter.cpp Fri Jul 29 17:43:06 2011
@@ -869,7 +869,7 @@
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 @@
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 @@
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 @@
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;
Modified: llvm/trunk/utils/TableGen/CallingConvEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/CallingConvEmitter.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/CallingConvEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/CallingConvEmitter.cpp Fri Jul 29 17:43:06 2011
@@ -40,7 +40,7 @@
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 @@
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 @@
<< "(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 @@
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";
Modified: llvm/trunk/utils/TableGen/ClangAttrEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/ClangAttrEmitter.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/ClangAttrEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/ClangAttrEmitter.cpp Fri Jul 29 17:43:06 2011
@@ -21,7 +21,7 @@
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;
@@ -31,9 +31,9 @@
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");
Modified: llvm/trunk/utils/TableGen/ClangDiagnosticsEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/ClangDiagnosticsEmitter.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/ClangDiagnosticsEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/ClangDiagnosticsEmitter.cpp Fri Jul 29 17:43:06 2011
@@ -74,7 +74,7 @@
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);
@@ -159,7 +159,7 @@
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 {
@@ -225,7 +225,7 @@
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);
Modified: llvm/trunk/utils/TableGen/ClangSACheckersEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/ClangSACheckersEmitter.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/ClangSACheckersEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/ClangSACheckersEmitter.cpp Fri Jul 29 17:43:06 2011
@@ -28,7 +28,7 @@
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;
@@ -42,7 +42,7 @@
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;
}
@@ -63,8 +63,8 @@
}
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();
}
@@ -129,8 +129,8 @@
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!";
@@ -149,21 +149,21 @@
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;
@@ -204,7 +204,7 @@
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, ";
@@ -232,7 +232,7 @@
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, ";
Modified: llvm/trunk/utils/TableGen/CodeEmitterGen.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/CodeEmitterGen.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/CodeEmitterGen.cpp (original)
+++ llvm/trunk/utils/TableGen/CodeEmitterGen.cpp Fri Jul 29 17:43:06 2011
@@ -38,16 +38,16 @@
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);
+ SmallVector<Init *, 16> NewBits(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);
+ Init *OrigBit = BI->getBit(bit);
+ Init *BitSwap = BI->getBit(bitSwapIdx);
NewBits[bit] = BitSwap;
NewBits[bitSwapIdx] = OrigBit;
}
@@ -56,7 +56,7 @@
NewBits[middle] = BI->getBit(middle);
}
- const BitsInit *NewBI = BitsInit::get(NewBits);
+ BitsInit *NewBI = BitsInit::get(NewBits);
// Update the bits in reversed order so that emitInstrOpBits will get the
// correct endianness.
@@ -67,12 +67,12 @@
// 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;
}
@@ -81,7 +81,7 @@
}
void CodeEmitterGen::
-AddCodeToMergeInOperand(Record *R, const BitsInit *BI, const std::string &VarName,
+AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName,
unsigned &NumberedOp,
std::string &Case, CodeGenTarget &Target) {
CodeGenInstruction &CGI = Target.getInstruction(R);
@@ -185,7 +185,7 @@
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;
@@ -242,12 +242,12 @@
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";
Modified: llvm/trunk/utils/TableGen/CodeEmitterGen.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/CodeEmitterGen.h?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/CodeEmitterGen.h (original)
+++ llvm/trunk/utils/TableGen/CodeEmitterGen.h Fri Jul 29 17:43:06 2011
@@ -35,10 +35,10 @@
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,
+ AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName,
unsigned &NumberedOp,
std::string &Case, CodeGenTarget &Target);
Modified: llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp (original)
+++ llvm/trunk/utils/TableGen/CodeGenDAGPatterns.cpp Fri Jul 29 17:43:06 2011
@@ -583,7 +583,7 @@
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 @@
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 @@
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,7 +742,7 @@
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
@@ -866,12 +866,12 @@
// 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);
@@ -1021,10 +1021,10 @@
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);
}
@@ -1098,8 +1098,8 @@
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()));
@@ -1155,9 +1155,9 @@
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!");
@@ -1319,7 +1319,7 @@
return 0;
unsigned IID =
- dynamic_cast<const IntInit*>(getChild(0)->getLeafValue())->getValue();
+ dynamic_cast<IntInit*>(getChild(0)->getLeafValue())->getValue();
return &CDP.getIntrinsicInfo(IID);
}
@@ -1329,7 +1329,7 @@
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;
@@ -1382,7 +1382,7 @@
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)
@@ -1391,7 +1391,7 @@
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. :)
@@ -1651,7 +1651,7 @@
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;
}
@@ -1701,14 +1701,14 @@
// 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, ""));
@@ -1739,8 +1739,8 @@
}
-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
@@ -1749,7 +1749,7 @@
if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag"))
return ParseTreePattern(
DagInit::get(DI, "",
- std::vector<std::pair<const Init*, std::string> >()),
+ std::vector<std::pair<Init*, std::string> >()),
OpName);
// Input argument?
@@ -1764,26 +1764,26 @@
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(IntRecTy::get());
- if (II == 0 || !dynamic_cast<const IntInit*>(II))
+ Init *II = BI->convertInitializerTo(IntRecTy::get());
+ 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();
@@ -1948,7 +1948,7 @@
// 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;
@@ -2097,7 +2097,7 @@
// 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;
@@ -2109,8 +2109,8 @@
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 ||
@@ -2122,8 +2122,8 @@
// 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())
@@ -2181,19 +2181,19 @@
// Find some SDNode.
assert(!SDNodes.empty() && "No SDNodes parsed?");
- const Init *SomeSDNode = DefInit::get(SDNodes.begin()->first);
+ Init *SomeSDNode = DefInit::get(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 = DagInit::get(SomeSDNode, "", Ops);
// Create a TreePattern to parse this.
TreePattern P(DefaultOps[iter][i], DI, false, *this);
@@ -2232,7 +2232,7 @@
// 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!");
@@ -2242,7 +2242,7 @@
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 {
@@ -2260,7 +2260,7 @@
}
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();
@@ -2295,7 +2295,7 @@
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());
@@ -2336,7 +2336,7 @@
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!");
@@ -2402,7 +2402,7 @@
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);
@@ -2419,7 +2419,7 @@
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")) {
@@ -2526,9 +2526,9 @@
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
@@ -2620,7 +2620,7 @@
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!");
@@ -2665,8 +2665,8 @@
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");
@@ -2866,13 +2866,13 @@
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.
@@ -3184,7 +3184,7 @@
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;
Modified: llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h (original)
+++ llvm/trunk/utils/TableGen/CodeGenDAGPatterns.h Fri Jul 29 17:43:06 2011
@@ -306,7 +306,7 @@
/// 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 @@
: 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 @@
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 @@
/// 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 @@
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 @@
/// 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 @@
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 @@
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; }
Modified: llvm/trunk/utils/TableGen/CodeGenInstruction.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/CodeGenInstruction.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/CodeGenInstruction.cpp (original)
+++ llvm/trunk/utils/TableGen/CodeGenInstruction.cpp Fri Jul 29 17:43:06 2011
@@ -30,9 +30,9 @@
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
@@ -40,8 +40,8 @@
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
@@ -50,7 +50,7 @@
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);
@@ -60,7 +60,7 @@
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 +69,7 @@
std::string EncoderMethod;
std::string OperandType = "OPERAND_UNKNOWN";
unsigned NumOps = 1;
- const DagInit *MIOpInfo = 0;
+ DagInit *MIOpInfo = 0;
if (Rec->isSubClassOf("RegisterOperand")) {
PrintMethod = Rec->getValueAsString("PrintMethod");
} else if (Rec->isSubClassOf("Operand")) {
@@ -80,8 +80,8 @@
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";
@@ -182,7 +182,7 @@
}
// 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 + "'";
@@ -405,12 +405,12 @@
/// 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
@@ -456,7 +456,7 @@
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.
@@ -475,7 +475,7 @@
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");
@@ -485,7 +485,7 @@
// 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)
@@ -524,11 +524,11 @@
// 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);
Modified: llvm/trunk/utils/TableGen/CodeGenInstruction.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/CodeGenInstruction.h?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/CodeGenInstruction.h (original)
+++ llvm/trunk/utils/TableGen/CodeGenInstruction.h Fri Jul 29 17:43:06 2011
@@ -98,7 +98,7 @@
/// 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.
@@ -106,7 +106,7 @@
OperandInfo(Record *R, const std::string &N, const std::string &PMN,
const std::string &EMN, const std::string &OT, unsigned MION,
- unsigned MINO, const DagInit *MIOI)
+ unsigned MINO, DagInit *MIOI)
: Rec(R), Name(N), PrinterMethodName(PMN), EncoderMethodName(EMN),
OperandType(OT), MIOperandNo(MION), MINumOperands(MINO),
MIOperandInfo(MIOI) {}
@@ -270,7 +270,7 @@
std::string AsmString;
/// Result - The result instruction.
- const DagInit *Result;
+ DagInit *Result;
/// ResultInst - The instruction generated by the alias (decoded from
/// Result).
@@ -316,7 +316,7 @@
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);
};
Modified: llvm/trunk/utils/TableGen/CodeGenRegisters.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/CodeGenRegisters.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/CodeGenRegisters.cpp (original)
+++ llvm/trunk/utils/TableGen/CodeGenRegisters.cpp Fri Jul 29 17:43:06 2011
@@ -91,14 +91,14 @@
}
// 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());
@@ -107,7 +107,7 @@
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());
@@ -163,7 +163,7 @@
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)
@@ -183,13 +183,13 @@
// Precompute some types.
Record *RegisterCl = Def->getRecords().getClass("Register");
RecTy *RegisterRecTy = RecordRecTy::get(RegisterCl);
- const StringInit *BlankName = StringInit::get("");
+ StringInit *BlankName = StringInit::get("");
// 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];
@@ -278,7 +278,7 @@
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) {
@@ -295,11 +295,11 @@
}
// 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() +
@@ -307,7 +307,7 @@
// 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() +
Modified: llvm/trunk/utils/TableGen/CodeGenTarget.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/CodeGenTarget.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/CodeGenTarget.cpp (original)
+++ llvm/trunk/utils/TableGen/CodeGenTarget.cpp Fri Jul 29 17:43:06 2011
@@ -402,7 +402,7 @@
// 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 @@
}
// 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") &&
Modified: llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp (original)
+++ llvm/trunk/utils/TableGen/DAGISelMatcherGen.cpp Fri Jul 29 17:43:06 2011
@@ -203,7 +203,7 @@
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 @@
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,7 +283,7 @@
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
@@ -496,7 +496,7 @@
--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.
@@ -572,14 +572,14 @@
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 =
Modified: llvm/trunk/utils/TableGen/FastISelEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/FastISelEmitter.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/FastISelEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/FastISelEmitter.cpp Fri Jul 29 17:43:06 2011
@@ -241,7 +241,7 @@
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 @@
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 @@
// 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
Modified: llvm/trunk/utils/TableGen/FixedLenDecoderEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/FixedLenDecoderEmitter.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/FixedLenDecoderEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/FixedLenDecoderEmitter.cpp Fri Jul 29 17:43:06 2011
@@ -48,15 +48,15 @@
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 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;
}
@@ -277,7 +277,7 @@
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 < BitWidth; ++i)
Insn.push_back(bitFromBits(Bits, i));
@@ -1194,7 +1194,7 @@
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;
@@ -1215,9 +1215,9 @@
// 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)
@@ -1235,7 +1235,7 @@
}
// 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) {
std::string Decoder = "";
@@ -1244,7 +1244,7 @@
// 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;
@@ -1256,8 +1256,8 @@
}
RecordVal *DecoderString = TypeRecord->getValue("DecoderMethod");
- const StringInit *String = DecoderString ?
- dynamic_cast<const StringInit*>(DecoderString->getValue()) : 0;
+ StringInit *String = DecoderString ?
+ dynamic_cast<StringInit*>(DecoderString->getValue()) : 0;
if (!isReg && String && String->getValue() != "")
Decoder = String->getValue();
@@ -1267,7 +1267,7 @@
unsigned Offset = 0;
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) {
if (Base != ~0U) {
OpInfo.addField(Base, Width, Offset);
@@ -1277,9 +1277,8 @@
}
continue;
}
- if (!BI) continue;
- const VarInit *Var = dynamic_cast<const VarInit*>(BI->getVariable());
+ VarInit *Var = dynamic_cast<VarInit*>(BI->getVariable());
assert(Var);
if (Var->getName() != NI->second &&
Var->getName() != TiedNames[NI->second]) {
Modified: llvm/trunk/utils/TableGen/InstrInfoEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/InstrInfoEmitter.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/InstrInfoEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/InstrInfoEmitter.cpp Fri Jul 29 17:43:06 2011
@@ -61,7 +61,7 @@
// 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 @@
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;
}
}
@@ -295,11 +295,11 @@
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();
Modified: llvm/trunk/utils/TableGen/LLVMCConfigurationEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/LLVMCConfigurationEmitter.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/LLVMCConfigurationEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/LLVMCConfigurationEmitter.cpp Fri Jul 29 17:43:06 2011
@@ -245,7 +245,7 @@
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 @@
}
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 @@
/// operator() - Just forwards to the corresponding property
/// handler.
- void operator() (const Init* I) {
+ void operator() (Init* I) {
InvokeDagInitHandler(this, I);
}
@@ -705,10 +705,10 @@
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 @@
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 @@
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 @@
}
}
- void operator() (const Init* I) {
+ void operator() (Init* I) {
InvokeDagInitHandler(this, I);
}
@@ -915,9 +915,9 @@
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 @@
isReallyJoin = true;
}
else {
- const Init* I = d.getArg(0);
+ Init* I = d.getArg(0);
isReallyJoin = InitPtrToBool(I);
}
@@ -1007,7 +1007,7 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
}
}
- void operator() (const Init* I) {
+ void operator() (Init* I) {
InvokeDagInitHandler(this, I);
}
@@ -2655,7 +2655,7 @@
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 @@
// 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 @@
// 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
Modified: llvm/trunk/utils/TableGen/OptParserEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/OptParserEmitter.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/OptParserEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/OptParserEmitter.cpp Fri Jul 29 17:43:06 2011
@@ -56,7 +56,7 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
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 @@
// 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";
Modified: llvm/trunk/utils/TableGen/PseudoLoweringEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/PseudoLoweringEmitter.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/PseudoLoweringEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/PseudoLoweringEmitter.cpp Fri Jul 29 17:43:06 2011
@@ -24,11 +24,11 @@
// 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,11 +54,11 @@
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 =
@@ -77,11 +77,11 @@
// 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!");
Modified: llvm/trunk/utils/TableGen/PseudoLoweringEmitter.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/PseudoLoweringEmitter.h?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/PseudoLoweringEmitter.h (original)
+++ llvm/trunk/utils/TableGen/PseudoLoweringEmitter.h Fri Jul 29 17:43:06 2011
@@ -47,7 +47,7 @@
SmallVector<PseudoExpansion, 64> Expansions;
- unsigned addDagOperandMapping(Record *Rec, const DagInit *Dag,
+ unsigned addDagOperandMapping(Record *Rec, DagInit *Dag,
CodeGenInstruction &Insn,
IndexedMap<OpData> &OperandMap,
unsigned BaseIdx);
Modified: llvm/trunk/utils/TableGen/Record.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/Record.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/Record.cpp (original)
+++ llvm/trunk/utils/TableGen/Record.cpp Fri Jul 29 17:43:06 2011
@@ -88,7 +88,7 @@
return ListTy;
}
-const Init *BitRecTy::convertValue(const BitsInit *BI) {
+Init *BitRecTy::convertValue(BitsInit *BI) {
if (BI->getNumBits() != 1) return 0; // Only accept if just one bit!
return BI->getBit(0);
}
@@ -97,14 +97,14 @@
return RHS->getNumBits() == 1;
}
-const Init *BitRecTy::convertValue(const IntInit *II) {
+Init *BitRecTy::convertValue(IntInit *II) {
int64_t Val = II->getValue();
if (Val != 0 && Val != 1) return 0; // Only accept 0 or 1 for a bit!
return BitInit::get(Val != 0);
}
-const Init *BitRecTy::convertValue(const TypedInit *VI) {
+Init *BitRecTy::convertValue(TypedInit *VI) {
if (dynamic_cast<BitRecTy*>(VI->getType()))
return VI; // Accept variable if it is already of bit type!
return 0;
@@ -124,8 +124,8 @@
return "bits<" + utostr(Size) + ">";
}
-const Init *BitsRecTy::convertValue(const UnsetInit *UI) {
- SmallVector<const Init *, 16> NewBits(Size);
+Init *BitsRecTy::convertValue(UnsetInit *UI) {
+ SmallVector<Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
NewBits[i] = UnsetInit::get();
@@ -133,7 +133,7 @@
return BitsInit::get(NewBits);
}
-const Init *BitsRecTy::convertValue(const BitInit *UI) {
+Init *BitsRecTy::convertValue(BitInit *UI) {
if (Size != 1) return 0; // Can only convert single bit.
return BitsInit::get(UI);
}
@@ -149,13 +149,13 @@
/// convertValue from Int initializer to bits type: Split the integer up into the
/// appropriate bits.
///
-const Init *BitsRecTy::convertValue(const IntInit *II) {
+Init *BitsRecTy::convertValue(IntInit *II) {
int64_t Value = II->getValue();
// Make sure this bitfield is large enough to hold the integer value.
if (!canFitInBitfield(Value, Size))
return 0;
- SmallVector<const Init *, 16> NewBits(Size);
+ SmallVector<Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
NewBits[i] = BitInit::get(Value & (1LL << i));
@@ -163,17 +163,17 @@
return BitsInit::get(NewBits);
}
-const Init *BitsRecTy::convertValue(const BitsInit *BI) {
+Init *BitsRecTy::convertValue(BitsInit *BI) {
// If the number of bits is right, return it. Otherwise we need to expand or
// truncate.
if (BI->getNumBits() == Size) return BI;
return 0;
}
-const Init *BitsRecTy::convertValue(const TypedInit *VI) {
+Init *BitsRecTy::convertValue(TypedInit *VI) {
if (BitsRecTy *BRT = dynamic_cast<BitsRecTy*>(VI->getType()))
if (BRT->Size == Size) {
- SmallVector<const Init *, 16> NewBits(Size);
+ SmallVector<Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
NewBits[i] = VarBitInit::get(VI, i);
@@ -183,21 +183,21 @@
if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType()))
return BitsInit::get(VI);
- if (const TernOpInit *Tern = dynamic_cast<const TernOpInit*>(VI)) {
+ if (TernOpInit *Tern = dynamic_cast<TernOpInit*>(VI)) {
if (Tern->getOpcode() == TernOpInit::IF) {
- const Init *LHS = Tern->getLHS();
- const Init *MHS = Tern->getMHS();
- const Init *RHS = Tern->getRHS();
+ Init *LHS = Tern->getLHS();
+ Init *MHS = Tern->getMHS();
+ Init *RHS = Tern->getRHS();
- const IntInit *MHSi = dynamic_cast<const IntInit*>(MHS);
- const IntInit *RHSi = dynamic_cast<const IntInit*>(RHS);
+ IntInit *MHSi = dynamic_cast<IntInit*>(MHS);
+ IntInit *RHSi = dynamic_cast<IntInit*>(RHS);
if (MHSi && RHSi) {
int64_t MHSVal = MHSi->getValue();
int64_t RHSVal = RHSi->getValue();
if (canFitInBitfield(MHSVal, Size) && canFitInBitfield(RHSVal, Size)) {
- SmallVector<const Init *, 16> NewBits(Size);
+ SmallVector<Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
NewBits[i] =
@@ -209,11 +209,11 @@
return BitsInit::get(NewBits);
}
} else {
- const BitsInit *MHSbs = dynamic_cast<const BitsInit*>(MHS);
- const BitsInit *RHSbs = dynamic_cast<const BitsInit*>(RHS);
+ BitsInit *MHSbs = dynamic_cast<BitsInit*>(MHS);
+ BitsInit *RHSbs = dynamic_cast<BitsInit*>(RHS);
if (MHSbs && RHSbs) {
- SmallVector<const Init *, 16> NewBits(Size);
+ SmallVector<Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
NewBits[i] = TernOpInit::get(TernOpInit::IF, LHS,
@@ -230,14 +230,14 @@
return 0;
}
-const Init *IntRecTy::convertValue(const BitInit *BI) {
+Init *IntRecTy::convertValue(BitInit *BI) {
return IntInit::get(BI->getValue());
}
-const Init *IntRecTy::convertValue(const BitsInit *BI) {
+Init *IntRecTy::convertValue(BitsInit *BI) {
int64_t Result = 0;
for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
- if (const BitInit *Bit = dynamic_cast<const BitInit*>(BI->getBit(i))) {
+ if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) {
Result |= Bit->getValue() << i;
} else {
return 0;
@@ -245,39 +245,39 @@
return IntInit::get(Result);
}
-const Init *IntRecTy::convertValue(const TypedInit *TI) {
+Init *IntRecTy::convertValue(TypedInit *TI) {
if (TI->getType()->typeIsConvertibleTo(this))
return TI; // Accept variable if already of the right type!
return 0;
}
-const Init *StringRecTy::convertValue(const UnOpInit *BO) {
+Init *StringRecTy::convertValue(UnOpInit *BO) {
if (BO->getOpcode() == UnOpInit::CAST) {
- const Init *L = BO->getOperand()->convertInitializerTo(this);
+ Init *L = BO->getOperand()->convertInitializerTo(this);
if (L == 0) return 0;
if (L != BO->getOperand())
return UnOpInit::get(UnOpInit::CAST, L, new StringRecTy);
return BO;
}
- return convertValue((const TypedInit*)BO);
+ return convertValue((TypedInit*)BO);
}
-const Init *StringRecTy::convertValue(const BinOpInit *BO) {
+Init *StringRecTy::convertValue(BinOpInit *BO) {
if (BO->getOpcode() == BinOpInit::STRCONCAT) {
- const Init *L = BO->getLHS()->convertInitializerTo(this);
- const Init *R = BO->getRHS()->convertInitializerTo(this);
+ Init *L = BO->getLHS()->convertInitializerTo(this);
+ Init *R = BO->getRHS()->convertInitializerTo(this);
if (L == 0 || R == 0) return 0;
if (L != BO->getLHS() || R != BO->getRHS())
return BinOpInit::get(BinOpInit::STRCONCAT, L, R, new StringRecTy);
return BO;
}
- return convertValue((const TypedInit*)BO);
+ return convertValue((TypedInit*)BO);
}
-const Init *StringRecTy::convertValue(const TypedInit *TI) {
+Init *StringRecTy::convertValue(TypedInit *TI) {
if (dynamic_cast<StringRecTy*>(TI->getType()))
return TI; // Accept variable if already of the right type!
return 0;
@@ -287,13 +287,13 @@
return "list<" + Ty->getAsString() + ">";
}
-const Init *ListRecTy::convertValue(const ListInit *LI) {
- std::vector<const Init*> Elements;
+Init *ListRecTy::convertValue(ListInit *LI) {
+ std::vector<Init*> Elements;
// Verify that all of the elements of the list are subclasses of the
// appropriate class!
for (unsigned i = 0, e = LI->getSize(); i != e; ++i)
- if (const Init *CI = LI->getElement(i)->convertInitializerTo(Ty))
+ if (Init *CI = LI->getElement(i)->convertInitializerTo(Ty))
Elements.push_back(CI);
else
return 0;
@@ -306,7 +306,7 @@
return ListInit::get(Elements, this);
}
-const Init *ListRecTy::convertValue(const TypedInit *TI) {
+Init *ListRecTy::convertValue(TypedInit *TI) {
// Ensure that TI is compatible with our class.
if (ListRecTy *LRT = dynamic_cast<ListRecTy*>(TI->getType()))
if (LRT->getElementType()->typeIsConvertibleTo(getElementType()))
@@ -314,21 +314,21 @@
return 0;
}
-const Init *CodeRecTy::convertValue(const TypedInit *TI) {
+Init *CodeRecTy::convertValue(TypedInit *TI) {
if (TI->getType()->typeIsConvertibleTo(this))
return TI;
return 0;
}
-const Init *DagRecTy::convertValue(const TypedInit *TI) {
+Init *DagRecTy::convertValue(TypedInit *TI) {
if (TI->getType()->typeIsConvertibleTo(this))
return TI;
return 0;
}
-const Init *DagRecTy::convertValue(const UnOpInit *BO) {
+Init *DagRecTy::convertValue(UnOpInit *BO) {
if (BO->getOpcode() == UnOpInit::CAST) {
- const Init *L = BO->getOperand()->convertInitializerTo(this);
+ Init *L = BO->getOperand()->convertInitializerTo(this);
if (L == 0) return 0;
if (L != BO->getOperand())
return UnOpInit::get(UnOpInit::CAST, L, new DagRecTy);
@@ -337,10 +337,10 @@
return 0;
}
-const Init *DagRecTy::convertValue(const BinOpInit *BO) {
+Init *DagRecTy::convertValue(BinOpInit *BO) {
if (BO->getOpcode() == BinOpInit::CONCAT) {
- const Init *L = BO->getLHS()->convertInitializerTo(this);
- const Init *R = BO->getRHS()->convertInitializerTo(this);
+ Init *L = BO->getLHS()->convertInitializerTo(this);
+ Init *R = BO->getRHS()->convertInitializerTo(this);
if (L == 0 || R == 0) return 0;
if (L != BO->getLHS() || R != BO->getRHS())
return BinOpInit::get(BinOpInit::CONCAT, L, R, new DagRecTy);
@@ -357,14 +357,14 @@
return Rec->getName();
}
-const Init *RecordRecTy::convertValue(const DefInit *DI) {
+Init *RecordRecTy::convertValue(DefInit *DI) {
// Ensure that DI is a subclass of Rec.
if (!DI->getDef()->isSubClassOf(Rec))
return 0;
return DI;
}
-const Init *RecordRecTy::convertValue(const TypedInit *TI) {
+Init *RecordRecTy::convertValue(TypedInit *TI) {
// Ensure that TI is compatible with Rec.
if (RecordRecTy *RRT = dynamic_cast<RecordRecTy*>(TI->getType()))
if (RRT->getRecord()->isSubClassOf(getRecord()) ||
@@ -445,30 +445,30 @@
void Init::dump() const { return print(errs()); }
-const UnsetInit *UnsetInit::get() {
- static const UnsetInit TheInit;
+UnsetInit *UnsetInit::get() {
+ static UnsetInit TheInit;
return &TheInit;
}
-const BitInit *BitInit::get(bool V) {
- static const BitInit True(true);
- static const BitInit False(false);
+BitInit *BitInit::get(bool V) {
+ static BitInit True(true);
+ static BitInit False(false);
return V ? &True : &False;
}
static void
-ProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<const Init *> Range) {
+ProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) {
ID.AddInteger(Range.size());
- for (ArrayRef<const Init *>::iterator i = Range.begin(),
+ for (ArrayRef<Init *>::iterator i = Range.begin(),
iend = Range.end();
i != iend;
++i)
ID.AddPointer(*i);
}
-const BitsInit *BitsInit::get(ArrayRef<const Init *> Range) {
+BitsInit *BitsInit::get(ArrayRef<Init *> Range) {
typedef FoldingSet<BitsInit> Pool;
static Pool ThePool;
@@ -476,7 +476,7 @@
ProfileBitsInit(ID, Range);
void *IP = 0;
- if (const BitsInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
+ if (BitsInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
return I;
BitsInit *I = new BitsInit(Range);
@@ -489,9 +489,9 @@
ProfileBitsInit(ID, Bits);
}
-const Init *
+Init *
BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
- SmallVector<const Init *, 16> NewBits(Bits.size());
+ SmallVector<Init *, 16> NewBits(Bits.size());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= getNumBits())
@@ -505,7 +505,7 @@
std::string Result = "{ ";
for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
if (i) Result += ", ";
- if (const Init *Bit = getBit(e-i-1))
+ if (Init *Bit = getBit(e-i-1))
Result += Bit->getAsString();
else
Result += "*";
@@ -516,13 +516,13 @@
// resolveReferences - If there are any field references that refer to fields
// that have been filled in, we can propagate the values now.
//
-const Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) const {
+Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) const {
bool Changed = false;
- SmallVector<const Init *, 16> NewBits(getNumBits());
+ SmallVector<Init *, 16> NewBits(getNumBits());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
- const Init *B;
- const Init *CurBit = getBit(i);
+ Init *B;
+ Init *CurBit = getBit(i);
do {
B = CurBit;
@@ -535,10 +535,10 @@
if (Changed)
return BitsInit::get(NewBits);
- return this;
+ return const_cast<BitsInit *>(this);
}
-const IntInit *IntInit::get(int64_t V) {
+IntInit *IntInit::get(int64_t V) {
typedef DenseMap<int64_t, IntInit *> Pool;
static Pool ThePool;
@@ -551,9 +551,9 @@
return itostr(Value);
}
-const Init *
+Init *
IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
- SmallVector<const Init *, 16> NewBits(Bits.size());
+ SmallVector<Init *, 16> NewBits(Bits.size());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= 64)
@@ -564,7 +564,7 @@
return BitsInit::get(NewBits);
}
-const StringInit *StringInit::get(const std::string &V) {
+StringInit *StringInit::get(const std::string &V) {
typedef StringMap<StringInit *> Pool;
static Pool ThePool;
@@ -573,7 +573,7 @@
return I;
}
-const CodeInit *CodeInit::get(const std::string &V) {
+CodeInit *CodeInit::get(const std::string &V) {
typedef StringMap<CodeInit *> Pool;
static Pool ThePool;
@@ -583,19 +583,19 @@
}
static void ProfileListInit(FoldingSetNodeID &ID,
- ArrayRef<const Init *> Range,
+ ArrayRef<Init *> Range,
RecTy *EltTy) {
ID.AddInteger(Range.size());
ID.AddPointer(EltTy);
- for (ArrayRef<const Init *>::iterator i = Range.begin(),
+ for (ArrayRef<Init *>::iterator i = Range.begin(),
iend = Range.end();
i != iend;
++i)
ID.AddPointer(*i);
}
-const ListInit *ListInit::get(ArrayRef<const Init *> Range, RecTy *EltTy) {
+ListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) {
typedef FoldingSet<ListInit> Pool;
static Pool ThePool;
@@ -605,7 +605,7 @@
ProfileListInit(ID, Range, EltTy);
void *IP = 0;
- if (const ListInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
+ if (ListInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
return I;
ListInit *I = new ListInit(Range, EltTy);
@@ -621,9 +621,9 @@
ProfileListInit(ID, Values, EltTy);
}
-const Init *
+Init *
ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const {
- std::vector<const Init*> Vals;
+ std::vector<Init*> Vals;
for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
if (Elements[i] >= getSize())
return 0;
@@ -634,19 +634,19 @@
Record *ListInit::getElementAsRecord(unsigned i) const {
assert(i < Values.size() && "List element index out of range!");
- const DefInit *DI = dynamic_cast<const DefInit*>(Values[i]);
+ DefInit *DI = dynamic_cast<DefInit*>(Values[i]);
if (DI == 0) throw "Expected record in list!";
return DI->getDef();
}
-const Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) const {
- std::vector<const Init*> Resolved;
+Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) const {
+ std::vector<Init*> Resolved;
Resolved.reserve(getSize());
bool Changed = false;
for (unsigned i = 0, e = getSize(); i != e; ++i) {
- const Init *E;
- const Init *CurElt = getElement(i);
+ Init *E;
+ Init *CurElt = getElement(i);
do {
E = CurElt;
@@ -658,19 +658,18 @@
if (Changed)
return ListInit::get(Resolved, getType());
- return this;
+ return const_cast<ListInit *>(this);
}
-const Init *ListInit::resolveListElementReference(Record &R,
- const RecordVal *IRV,
- unsigned Elt) const {
+Init *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV,
+ unsigned Elt) const {
if (Elt >= getSize())
return 0; // Out of range reference.
- const Init *E = getElement(Elt);
+ Init *E = getElement(Elt);
// If the element is set to some value, or if we are resolving a reference
// to a specific variable and that variable is explicitly unset, then
// replace the VarListElementInit with it.
- if (IRV || !dynamic_cast<const UnsetInit*>(E))
+ if (IRV || !dynamic_cast<UnsetInit*>(E))
return E;
return 0;
}
@@ -684,12 +683,12 @@
return Result + "]";
}
-const Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV,
- unsigned Bit) const {
- const Init *Folded = Fold(&R, 0);
+Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV,
+ unsigned Bit) const {
+ Init *Folded = Fold(&R, 0);
if (Folded != this) {
- const TypedInit *Typed = dynamic_cast<const TypedInit *>(Folded);
+ TypedInit *Typed = dynamic_cast<TypedInit *>(Folded);
if (Typed) {
return Typed->resolveBitReference(R, IRV, Bit);
}
@@ -698,12 +697,12 @@
return 0;
}
-const Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV,
- unsigned Elt) const {
- const Init *Folded = Fold(&R, 0);
+Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV,
+ unsigned Elt) const {
+ Init *Folded = Fold(&R, 0);
if (Folded != this) {
- const TypedInit *Typed = dynamic_cast<const TypedInit *>(Folded);
+ TypedInit *Typed = dynamic_cast<TypedInit *>(Folded);
if (Typed) {
return Typed->resolveListElementReference(R, IRV, Elt);
}
@@ -712,8 +711,8 @@
return 0;
}
-const UnOpInit *UnOpInit::get(UnaryOp opc, const Init *lhs, RecTy *Type) {
- typedef std::pair<std::pair<unsigned, const Init *>, RecTy *> Key;
+UnOpInit *UnOpInit::get(UnaryOp opc, Init *lhs, RecTy *Type) {
+ typedef std::pair<std::pair<unsigned, Init *>, RecTy *> Key;
typedef DenseMap<Key, UnOpInit *> Pool;
static Pool ThePool;
@@ -725,22 +724,22 @@
return I;
}
-const Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
+Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
switch (getOpcode()) {
default: assert(0 && "Unknown unop");
case CAST: {
if (getType()->getAsString() == "string") {
- const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+ StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
if (LHSs) {
return LHSs;
}
- const DefInit *LHSd = dynamic_cast<const DefInit*>(LHS);
+ DefInit *LHSd = dynamic_cast<DefInit*>(LHS);
if (LHSd) {
return StringInit::get(LHSd->getDef()->getName());
}
} else {
- const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+ StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
if (LHSs) {
std::string Name = LHSs->getValue();
@@ -786,7 +785,7 @@
break;
}
case HEAD: {
- const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
+ ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
if (LHSl) {
if (LHSl->getSize() == 0) {
assert(0 && "Empty list in car");
@@ -797,7 +796,7 @@
break;
}
case TAIL: {
- const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
+ ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
if (LHSl) {
if (LHSl->getSize() == 0) {
assert(0 && "Empty list in cdr");
@@ -805,17 +804,17 @@
}
// Note the +1. We can't just pass the result of getValues()
// directly.
- ArrayRef<const Init *>::iterator begin = LHSl->getValues().begin()+1;
- ArrayRef<const Init *>::iterator end = LHSl->getValues().end();
- const ListInit *Result =
- ListInit::get(ArrayRef<const Init *>(begin, end - begin),
+ ArrayRef<Init *>::iterator begin = LHSl->getValues().begin()+1;
+ ArrayRef<Init *>::iterator end = LHSl->getValues().end();
+ ListInit *Result =
+ ListInit::get(ArrayRef<Init *>(begin, end - begin),
LHSl->getType());
return Result;
}
break;
}
case EMPTY: {
- const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
+ ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
if (LHSl) {
if (LHSl->getSize() == 0) {
return IntInit::get(1);
@@ -823,7 +822,7 @@
return IntInit::get(0);
}
}
- const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+ StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
if (LHSs) {
if (LHSs->getValue().empty()) {
return IntInit::get(1);
@@ -835,11 +834,11 @@
break;
}
}
- return this;
+ return const_cast<UnOpInit *>(this);
}
-const Init *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) const {
- const Init *lhs = LHS->resolveReferences(R, RV);
+Init *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) const {
+ Init *lhs = LHS->resolveReferences(R, RV);
if (LHS != lhs)
return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, 0);
@@ -857,10 +856,10 @@
return Result + "(" + LHS->getAsString() + ")";
}
-const BinOpInit *BinOpInit::get(BinaryOp opc, const Init *lhs,
- const Init *rhs, RecTy *Type) {
+BinOpInit *BinOpInit::get(BinaryOp opc, Init *lhs,
+ Init *rhs, RecTy *Type) {
typedef std::pair<
- std::pair<std::pair<unsigned, const Init *>, const Init *>,
+ std::pair<std::pair<unsigned, Init *>, Init *>,
RecTy *
> Key;
@@ -875,18 +874,18 @@
return I;
}
-const Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
+Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
switch (getOpcode()) {
default: assert(0 && "Unknown binop");
case CONCAT: {
- const DagInit *LHSs = dynamic_cast<const DagInit*>(LHS);
- const DagInit *RHSs = dynamic_cast<const DagInit*>(RHS);
+ DagInit *LHSs = dynamic_cast<DagInit*>(LHS);
+ DagInit *RHSs = dynamic_cast<DagInit*>(RHS);
if (LHSs && RHSs) {
- const DefInit *LOp = dynamic_cast<const DefInit*>(LHSs->getOperator());
- const DefInit *ROp = dynamic_cast<const DefInit*>(RHSs->getOperator());
+ DefInit *LOp = dynamic_cast<DefInit*>(LHSs->getOperator());
+ DefInit *ROp = dynamic_cast<DefInit*>(RHSs->getOperator());
if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef())
throw "Concated Dag operators do not match!";
- std::vector<const Init*> Args;
+ std::vector<Init*> Args;
std::vector<std::string> ArgNames;
for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) {
Args.push_back(LHSs->getArg(i));
@@ -901,8 +900,8 @@
break;
}
case STRCONCAT: {
- const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
- const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS);
+ StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+ StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
if (LHSs && RHSs)
return StringInit::get(LHSs->getValue() + RHSs->getValue());
break;
@@ -910,16 +909,16 @@
case EQ: {
// try to fold eq comparison for 'bit' and 'int', otherwise fallback
// to string objects.
- const IntInit* L =
- dynamic_cast<const IntInit*>(LHS->convertInitializerTo(IntRecTy::get()));
- const IntInit* R =
- dynamic_cast<const IntInit*>(RHS->convertInitializerTo(IntRecTy::get()));
+ IntInit* L =
+ dynamic_cast<IntInit*>(LHS->convertInitializerTo(IntRecTy::get()));
+ IntInit* R =
+ dynamic_cast<IntInit*>(RHS->convertInitializerTo(IntRecTy::get()));
if (L && R)
return IntInit::get(L->getValue() == R->getValue());
- const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
- const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS);
+ StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+ StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
// Make sure we've resolved
if (LHSs && RHSs)
@@ -930,8 +929,8 @@
case SHL:
case SRA:
case SRL: {
- const IntInit *LHSi = dynamic_cast<const IntInit*>(LHS);
- const IntInit *RHSi = dynamic_cast<const IntInit*>(RHS);
+ IntInit *LHSi = dynamic_cast<IntInit*>(LHS);
+ IntInit *RHSi = dynamic_cast<IntInit*>(RHS);
if (LHSi && RHSi) {
int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue();
int64_t Result;
@@ -946,12 +945,12 @@
break;
}
}
- return this;
+ return const_cast<BinOpInit *>(this);
}
-const Init *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) const {
- const Init *lhs = LHS->resolveReferences(R, RV);
- const Init *rhs = RHS->resolveReferences(R, RV);
+Init *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) const {
+ Init *lhs = LHS->resolveReferences(R, RV);
+ Init *rhs = RHS->resolveReferences(R, RV);
if (LHS != lhs || RHS != rhs)
return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0);
@@ -971,15 +970,15 @@
return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
}
-const TernOpInit *TernOpInit::get(TernaryOp opc, const Init *lhs,
- const Init *mhs, const Init *rhs,
+TernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs,
+ Init *mhs, Init *rhs,
RecTy *Type) {
typedef std::pair<
std::pair<
- std::pair<std::pair<unsigned, RecTy *>, const Init *>,
- const Init *
+ std::pair<std::pair<unsigned, RecTy *>, Init *>,
+ Init *
>,
- const Init *
+ Init *
> Key;
typedef DenseMap<Key, TernOpInit *> Pool;
@@ -996,21 +995,19 @@
return I;
}
-static const Init *ForeachHelper(const Init *LHS, const Init *MHS,
- const Init *RHS, RecTy *Type,
- Record *CurRec, MultiClass *CurMultiClass);
-
-static const Init *EvaluateOperation(const OpInit *RHSo, const Init *LHS,
- const Init *Arg,
- RecTy *Type, Record *CurRec,
- MultiClass *CurMultiClass) {
- std::vector<const Init *> NewOperands;
+static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
+ Record *CurRec, MultiClass *CurMultiClass);
- const TypedInit *TArg = dynamic_cast<const TypedInit*>(Arg);
+static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
+ RecTy *Type, Record *CurRec,
+ MultiClass *CurMultiClass) {
+ std::vector<Init *> NewOperands;
+
+ TypedInit *TArg = dynamic_cast<TypedInit*>(Arg);
// If this is a dag, recurse
if (TArg && TArg->getType()->getAsString() == "dag") {
- const Init *Result = ForeachHelper(LHS, Arg, RHSo, Type,
+ Init *Result = ForeachHelper(LHS, Arg, RHSo, Type,
CurRec, CurMultiClass);
if (Result != 0) {
return Result;
@@ -1020,10 +1017,10 @@
}
for (int i = 0; i < RHSo->getNumOperands(); ++i) {
- const OpInit *RHSoo = dynamic_cast<const OpInit*>(RHSo->getOperand(i));
+ OpInit *RHSoo = dynamic_cast<OpInit*>(RHSo->getOperand(i));
if (RHSoo) {
- const Init *Result = EvaluateOperation(RHSoo, LHS, Arg,
+ Init *Result = EvaluateOperation(RHSoo, LHS, Arg,
Type, CurRec, CurMultiClass);
if (Result != 0) {
NewOperands.push_back(Result);
@@ -1039,30 +1036,28 @@
// Now run the operator and use its result as the new leaf
const OpInit *NewOp = RHSo->clone(NewOperands);
- const Init *NewVal = NewOp->Fold(CurRec, CurMultiClass);
+ Init *NewVal = NewOp->Fold(CurRec, CurMultiClass);
if (NewVal != NewOp)
return NewVal;
return 0;
}
-static const Init *ForeachHelper(const Init *LHS, const Init *MHS,
- const Init *RHS, RecTy *Type,
- Record *CurRec,
- MultiClass *CurMultiClass) {
- const DagInit *MHSd = dynamic_cast<const DagInit*>(MHS);
- const ListInit *MHSl = dynamic_cast<const ListInit*>(MHS);
+static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
+ Record *CurRec, MultiClass *CurMultiClass) {
+ DagInit *MHSd = dynamic_cast<DagInit*>(MHS);
+ ListInit *MHSl = dynamic_cast<ListInit*>(MHS);
DagRecTy *DagType = dynamic_cast<DagRecTy*>(Type);
ListRecTy *ListType = dynamic_cast<ListRecTy*>(Type);
- const OpInit *RHSo = dynamic_cast<const OpInit*>(RHS);
+ OpInit *RHSo = dynamic_cast<OpInit*>(RHS);
if (!RHSo) {
throw TGError(CurRec->getLoc(), "!foreach requires an operator\n");
}
- const TypedInit *LHSt = dynamic_cast<const TypedInit*>(LHS);
+ TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS);
if (!LHSt) {
throw TGError(CurRec->getLoc(), "!foreach requires typed variable\n");
@@ -1070,22 +1065,22 @@
if ((MHSd && DagType) || (MHSl && ListType)) {
if (MHSd) {
- const Init *Val = MHSd->getOperator();
- const Init *Result = EvaluateOperation(RHSo, LHS, Val,
+ Init *Val = MHSd->getOperator();
+ Init *Result = EvaluateOperation(RHSo, LHS, Val,
Type, CurRec, CurMultiClass);
if (Result != 0) {
Val = Result;
}
- std::vector<std::pair<const Init *, std::string> > args;
+ std::vector<std::pair<Init *, std::string> > args;
for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) {
- const Init *Arg;
+ Init *Arg;
std::string ArgName;
Arg = MHSd->getArg(i);
ArgName = MHSd->getArgName(i);
// Process args
- const Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type,
+ Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type,
CurRec, CurMultiClass);
if (Result != 0) {
Arg = Result;
@@ -1098,14 +1093,14 @@
return DagInit::get(Val, "", args);
}
if (MHSl) {
- std::vector<const Init *> NewOperands;
- std::vector<const Init *> NewList(MHSl->begin(), MHSl->end());
+ std::vector<Init *> NewOperands;
+ std::vector<Init *> NewList(MHSl->begin(), MHSl->end());
- for (std::vector<const Init *>::iterator li = NewList.begin(),
+ for (std::vector<Init *>::iterator li = NewList.begin(),
liend = NewList.end();
li != liend;
++li) {
- const Init *Item = *li;
+ Init *Item = *li;
NewOperands.clear();
for(int i = 0; i < RHSo->getNumOperands(); ++i) {
// First, replace the foreach variable with the list item
@@ -1118,7 +1113,7 @@
// Now run the operator and use its result as the new list item
const OpInit *NewOp = RHSo->clone(NewOperands);
- const Init *NewItem = NewOp->Fold(CurRec, CurMultiClass);
+ Init *NewItem = NewOp->Fold(CurRec, CurMultiClass);
if (NewItem != NewOp)
*li = NewItem;
}
@@ -1128,21 +1123,21 @@
return 0;
}
-const Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
+Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
switch (getOpcode()) {
default: assert(0 && "Unknown binop");
case SUBST: {
- const DefInit *LHSd = dynamic_cast<const DefInit*>(LHS);
- const VarInit *LHSv = dynamic_cast<const VarInit*>(LHS);
- const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
-
- const DefInit *MHSd = dynamic_cast<const DefInit*>(MHS);
- const VarInit *MHSv = dynamic_cast<const VarInit*>(MHS);
- const StringInit *MHSs = dynamic_cast<const StringInit*>(MHS);
-
- const DefInit *RHSd = dynamic_cast<const DefInit*>(RHS);
- const VarInit *RHSv = dynamic_cast<const VarInit*>(RHS);
- const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS);
+ DefInit *LHSd = dynamic_cast<DefInit*>(LHS);
+ VarInit *LHSv = dynamic_cast<VarInit*>(LHS);
+ StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+
+ DefInit *MHSd = dynamic_cast<DefInit*>(MHS);
+ VarInit *MHSv = dynamic_cast<VarInit*>(MHS);
+ StringInit *MHSs = dynamic_cast<StringInit*>(MHS);
+
+ DefInit *RHSd = dynamic_cast<DefInit*>(RHS);
+ VarInit *RHSv = dynamic_cast<VarInit*>(RHS);
+ StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
if ((LHSd && MHSd && RHSd)
|| (LHSv && MHSv && RHSv)
@@ -1181,7 +1176,7 @@
}
case FOREACH: {
- const Init *Result = ForeachHelper(LHS, MHS, RHS, getType(),
+ Init *Result = ForeachHelper(LHS, MHS, RHS, getType(),
CurRec, CurMultiClass);
if (Result != 0) {
return Result;
@@ -1190,9 +1185,9 @@
}
case IF: {
- const IntInit *LHSi = dynamic_cast<const IntInit*>(LHS);
- if (const Init *I = LHS->convertInitializerTo(IntRecTy::get()))
- LHSi = dynamic_cast<const IntInit*>(I);
+ IntInit *LHSi = dynamic_cast<IntInit*>(LHS);
+ if (Init *I = LHS->convertInitializerTo(IntRecTy::get()))
+ LHSi = dynamic_cast<IntInit*>(I);
if (LHSi) {
if (LHSi->getValue()) {
return MHS;
@@ -1204,33 +1199,33 @@
}
}
- return this;
+ return const_cast<TernOpInit *>(this);
}
-const Init *TernOpInit::resolveReferences(Record &R,
- const RecordVal *RV) const {
- const Init *lhs = LHS->resolveReferences(R, RV);
+Init *TernOpInit::resolveReferences(Record &R,
+ const RecordVal *RV) const {
+ Init *lhs = LHS->resolveReferences(R, RV);
if (Opc == IF && lhs != LHS) {
- const IntInit *Value = dynamic_cast<const IntInit*>(lhs);
- if (const Init *I = lhs->convertInitializerTo(IntRecTy::get()))
- Value = dynamic_cast<const IntInit*>(I);
+ IntInit *Value = dynamic_cast<IntInit*>(lhs);
+ if (Init *I = lhs->convertInitializerTo(IntRecTy::get()))
+ Value = dynamic_cast<IntInit*>(I);
if (Value != 0) {
// Short-circuit
if (Value->getValue()) {
- const Init *mhs = MHS->resolveReferences(R, RV);
+ Init *mhs = MHS->resolveReferences(R, RV);
return (TernOpInit::get(getOpcode(), lhs, mhs,
RHS, getType()))->Fold(&R, 0);
} else {
- const Init *rhs = RHS->resolveReferences(R, RV);
+ Init *rhs = RHS->resolveReferences(R, RV);
return (TernOpInit::get(getOpcode(), lhs, MHS,
rhs, getType()))->Fold(&R, 0);
}
}
}
- const Init *mhs = MHS->resolveReferences(R, RV);
- const Init *rhs = RHS->resolveReferences(R, RV);
+ Init *mhs = MHS->resolveReferences(R, RV);
+ Init *rhs = RHS->resolveReferences(R, RV);
if (LHS != lhs || MHS != mhs || RHS != rhs)
return (TernOpInit::get(getOpcode(), lhs, mhs, rhs,
@@ -1260,39 +1255,40 @@
return 0;
}
-const Init *
+Init *
TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
BitsRecTy *T = dynamic_cast<BitsRecTy*>(getType());
if (T == 0) return 0; // Cannot subscript a non-bits variable.
unsigned NumBits = T->getNumBits();
- SmallVector<const Init *, 16> NewBits(Bits.size());
+ SmallVector<Init *, 16> NewBits(Bits.size());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= NumBits)
return 0;
- NewBits[i] = VarBitInit::get(this, Bits[i]);
+ NewBits[i] = VarBitInit::get(const_cast<TypedInit *>(this), Bits[i]);
}
return BitsInit::get(NewBits);
}
-const Init *
+Init *
TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const {
ListRecTy *T = dynamic_cast<ListRecTy*>(getType());
if (T == 0) return 0; // Cannot subscript a non-list variable.
if (Elements.size() == 1)
- return VarListElementInit::get(this, Elements[0]);
+ return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]);
- std::vector<const Init*> ListInits;
+ std::vector<Init*> ListInits;
ListInits.reserve(Elements.size());
for (unsigned i = 0, e = Elements.size(); i != e; ++i)
- ListInits.push_back(VarListElementInit::get(this, Elements[i]));
+ ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this),
+ Elements[i]));
return ListInit::get(ListInits, T);
}
-const VarInit *VarInit::get(const std::string &VN, RecTy *T) {
+VarInit *VarInit::get(const std::string &VN, RecTy *T) {
typedef std::pair<RecTy *, TableGenStringKey> Key;
typedef DenseMap<Key, VarInit *> Pool;
static Pool ThePool;
@@ -1304,49 +1300,49 @@
return I;
}
-const Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV,
- unsigned Bit) const {
+Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV,
+ unsigned Bit) const {
if (R.isTemplateArg(getName())) return 0;
if (IRV && IRV->getName() != getName()) return 0;
RecordVal *RV = R.getValue(getName());
assert(RV && "Reference to a non-existent variable?");
- assert(dynamic_cast<const BitsInit*>(RV->getValue()));
- const BitsInit *BI = (const BitsInit*)RV->getValue();
+ assert(dynamic_cast<BitsInit*>(RV->getValue()));
+ BitsInit *BI = (BitsInit*)RV->getValue();
assert(Bit < BI->getNumBits() && "Bit reference out of range!");
- const Init *B = BI->getBit(Bit);
+ Init *B = BI->getBit(Bit);
// If the bit is set to some value, or if we are resolving a reference to a
// specific variable and that variable is explicitly unset, then replace the
// VarBitInit with it.
- if (IRV || !dynamic_cast<const UnsetInit*>(B))
+ if (IRV || !dynamic_cast<UnsetInit*>(B))
return B;
return 0;
}
-const Init *VarInit::resolveListElementReference(Record &R,
- const RecordVal *IRV,
- unsigned Elt) const {
+Init *VarInit::resolveListElementReference(Record &R,
+ const RecordVal *IRV,
+ unsigned Elt) const {
if (R.isTemplateArg(getName())) return 0;
if (IRV && IRV->getName() != getName()) return 0;
RecordVal *RV = R.getValue(getName());
assert(RV && "Reference to a non-existent variable?");
- const ListInit *LI = dynamic_cast<const ListInit*>(RV->getValue());
+ ListInit *LI = dynamic_cast<ListInit*>(RV->getValue());
if (!LI) {
- const VarInit *VI = dynamic_cast<const VarInit*>(RV->getValue());
+ VarInit *VI = dynamic_cast<VarInit*>(RV->getValue());
assert(VI && "Invalid list element!");
return VarListElementInit::get(VI, Elt);
}
if (Elt >= LI->getSize())
return 0; // Out of range reference.
- const Init *E = LI->getElement(Elt);
+ Init *E = LI->getElement(Elt);
// If the element is set to some value, or if we are resolving a reference
// to a specific variable and that variable is explicitly unset, then
// replace the VarListElementInit with it.
- if (IRV || !dynamic_cast<const UnsetInit*>(E))
+ if (IRV || !dynamic_cast<UnsetInit*>(E))
return E;
return 0;
}
@@ -1359,15 +1355,15 @@
return 0;
}
-const Init *VarInit::getFieldInit(Record &R, const RecordVal *RV,
- const std::string &FieldName) const {
+Init *VarInit::getFieldInit(Record &R, const RecordVal *RV,
+ const std::string &FieldName) const {
if (dynamic_cast<RecordRecTy*>(getType()))
if (const RecordVal *Val = R.getValue(VarName)) {
- if (RV != Val && (RV || dynamic_cast<const UnsetInit*>(Val->getValue())))
+ if (RV != Val && (RV || dynamic_cast<UnsetInit*>(Val->getValue())))
return 0;
- const Init *TheInit = Val->getValue();
+ Init *TheInit = Val->getValue();
assert(TheInit != this && "Infinite loop detected!");
- if (const Init *I = TheInit->getFieldInit(R, RV, FieldName))
+ if (Init *I = TheInit->getFieldInit(R, RV, FieldName))
return I;
else
return 0;
@@ -1380,15 +1376,15 @@
/// If a value is set for the variable later, this method will be called on
/// users of the value to allow the value to propagate out.
///
-const Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) const {
+Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) const {
if (RecordVal *Val = R.getValue(VarName))
- if (RV == Val || (RV == 0 && !dynamic_cast<const UnsetInit*>(Val->getValue())))
+ if (RV == Val || (RV == 0 && !dynamic_cast<UnsetInit*>(Val->getValue())))
return Val->getValue();
- return this;
+ return const_cast<VarInit *>(this);
}
-const VarBitInit *VarBitInit::get(const TypedInit *T, unsigned B) {
- typedef std::pair<const TypedInit *, unsigned> Key;
+VarBitInit *VarBitInit::get(TypedInit *T, unsigned B) {
+ typedef std::pair<TypedInit *, unsigned> Key;
typedef DenseMap<Key, VarBitInit *> Pool;
static Pool ThePool;
@@ -1404,16 +1400,15 @@
return TI->getAsString() + "{" + utostr(Bit) + "}";
}
-const Init *VarBitInit::resolveReferences(Record &R,
- const RecordVal *RV) const {
- if (const Init *I = getVariable()->resolveBitReference(R, RV, getBitNum()))
+Init *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) const {
+ if (Init *I = getVariable()->resolveBitReference(R, RV, getBitNum()))
return I;
- return this;
+ return const_cast<VarBitInit *>(this);
}
-const VarListElementInit *VarListElementInit::get(const TypedInit *T,
- unsigned E) {
- typedef std::pair<const TypedInit *, unsigned> Key;
+VarListElementInit *VarListElementInit::get(TypedInit *T,
+ unsigned E) {
+ typedef std::pair<TypedInit *, unsigned> Key;
typedef DenseMap<Key, VarListElementInit *> Pool;
static Pool ThePool;
@@ -1429,31 +1424,30 @@
return TI->getAsString() + "[" + utostr(Element) + "]";
}
-const Init *VarListElementInit::resolveReferences(Record &R,
- const RecordVal *RV) const {
- if (const Init *I = getVariable()->resolveListElementReference(R, RV,
+Init *
+VarListElementInit::resolveReferences(Record &R, const RecordVal *RV) const {
+ if (Init *I = getVariable()->resolveListElementReference(R, RV,
getElementNum()))
return I;
- return this;
+ return const_cast<VarListElementInit *>(this);
}
-const Init *VarListElementInit::resolveBitReference(Record &R,
- const RecordVal *RV,
- unsigned Bit) const {
+Init *VarListElementInit::resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const {
// FIXME: This should be implemented, to support references like:
// bit B = AA[0]{1};
return 0;
}
-const Init *VarListElementInit::
-resolveListElementReference(Record &R, const RecordVal *RV,
- unsigned Elt) const {
+Init *VarListElementInit:: resolveListElementReference(Record &R,
+ const RecordVal *RV,
+ unsigned Elt) const {
// FIXME: This should be implemented, to support references like:
// int B = AA[0][1];
return 0;
}
-const DefInit *DefInit::get(Record *R) {
+DefInit *DefInit::get(Record *R) {
return R->getDefInit();
}
@@ -1463,8 +1457,8 @@
return 0;
}
-const Init *DefInit::getFieldInit(Record &R, const RecordVal *RV,
- const std::string &FieldName) const {
+Init *DefInit::getFieldInit(Record &R, const RecordVal *RV,
+ const std::string &FieldName) const {
return Def->getValue(FieldName)->getValue();
}
@@ -1473,8 +1467,8 @@
return Def->getName();
}
-const FieldInit *FieldInit::get(const Init *R, const std::string &FN) {
- typedef std::pair<const Init *, TableGenStringKey> Key;
+FieldInit *FieldInit::get(Init *R, const std::string &FN) {
+ typedef std::pair<Init *, TableGenStringKey> Key;
typedef DenseMap<Key, FieldInit *> Pool;
static Pool ThePool;
@@ -1485,60 +1479,59 @@
return I;
}
-const Init *FieldInit::resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const {
- if (const Init *BitsVal = Rec->getFieldInit(R, RV, FieldName))
- if (const BitsInit *BI = dynamic_cast<const BitsInit*>(BitsVal)) {
+Init *FieldInit::resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const {
+ if (Init *BitsVal = Rec->getFieldInit(R, RV, FieldName))
+ if (BitsInit *BI = dynamic_cast<BitsInit*>(BitsVal)) {
assert(Bit < BI->getNumBits() && "Bit reference out of range!");
- const Init *B = BI->getBit(Bit);
+ Init *B = BI->getBit(Bit);
- if (dynamic_cast<const BitInit*>(B)) // If the bit is set.
+ if (dynamic_cast<BitInit*>(B)) // If the bit is set.
return B; // Replace the VarBitInit with it.
}
return 0;
}
-const Init *FieldInit::resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const {
- if (const Init *ListVal = Rec->getFieldInit(R, RV, FieldName))
- if (const ListInit *LI = dynamic_cast<const ListInit*>(ListVal)) {
+Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) const {
+ if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName))
+ if (ListInit *LI = dynamic_cast<ListInit*>(ListVal)) {
if (Elt >= LI->getSize()) return 0;
- const Init *E = LI->getElement(Elt);
+ Init *E = LI->getElement(Elt);
// If the element is set to some value, or if we are resolving a
// reference to a specific variable and that variable is explicitly
// unset, then replace the VarListElementInit with it.
- if (RV || !dynamic_cast<const UnsetInit*>(E))
+ if (RV || !dynamic_cast<UnsetInit*>(E))
return E;
}
return 0;
}
-const Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const {
- const Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec;
+Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const {
+ Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec;
- const Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName);
+ Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName);
if (BitsVal) {
- const Init *BVR = BitsVal->resolveReferences(R, RV);
- return BVR->isComplete() ? BVR : this;
+ Init *BVR = BitsVal->resolveReferences(R, RV);
+ return BVR->isComplete() ? BVR : const_cast<FieldInit *>(this);
}
if (NewRec != Rec) {
return FieldInit::get(NewRec, FieldName);
}
- return this;
+ return const_cast<FieldInit *>(this);
}
void ProfileDagInit(FoldingSetNodeID &ID,
- const Init *V,
+ Init *V,
const std::string &VN,
- ArrayRef<const Init *> ArgRange,
+ ArrayRef<Init *> ArgRange,
ArrayRef<std::string> NameRange) {
ID.AddPointer(V);
ID.AddString(VN);
- ArrayRef<const Init *>::iterator Arg = ArgRange.begin();
+ ArrayRef<Init *>::iterator Arg = ArgRange.begin();
ArrayRef<std::string>::iterator Name = NameRange.begin();
while (Arg != ArgRange.end()) {
assert(Name != NameRange.end() && "Arg name underflow!");
@@ -1548,9 +1541,9 @@
assert(Name == NameRange.end() && "Arg name overflow!");
}
-const DagInit *
-DagInit::get(const Init *V, const std::string &VN,
- ArrayRef<const Init *> ArgRange,
+DagInit *
+DagInit::get(Init *V, const std::string &VN,
+ ArrayRef<Init *> ArgRange,
ArrayRef<std::string> NameRange) {
typedef FoldingSet<DagInit> Pool;
static Pool ThePool;
@@ -1559,7 +1552,7 @@
ProfileDagInit(ID, V, VN, ArgRange, NameRange);
void *IP = 0;
- if (const DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
+ if (DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
return I;
DagInit *I = new DagInit(V, VN, ArgRange, NameRange);
@@ -1568,12 +1561,12 @@
return I;
}
-const DagInit *
-DagInit::get(const Init *V, const std::string &VN,
- const std::vector<std::pair<const Init*, std::string> > &args) {
- typedef std::pair<const Init*, std::string> PairType;
+DagInit *
+DagInit::get(Init *V, const std::string &VN,
+ const std::vector<std::pair<Init*, std::string> > &args) {
+ typedef std::pair<Init*, std::string> PairType;
- std::vector<const Init *> Args;
+ std::vector<Init *> Args;
std::vector<std::string> Names;
for (std::vector<PairType>::const_iterator i = args.begin(),
@@ -1591,17 +1584,17 @@
ProfileDagInit(ID, Val, ValName, Args, ArgNames);
}
-const Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) const {
- std::vector<const Init*> NewArgs;
+Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) const {
+ std::vector<Init*> NewArgs;
for (unsigned i = 0, e = Args.size(); i != e; ++i)
NewArgs.push_back(Args[i]->resolveReferences(R, RV));
- const Init *Op = Val->resolveReferences(R, RV);
+ Init *Op = Val->resolveReferences(R, RV);
if (Args != NewArgs || Op != Val)
return DagInit::get(Op, ValName, NewArgs, ArgNames);
- return this;
+ return const_cast<DagInit *>(this);
}
@@ -1668,7 +1661,7 @@
/// references.
void Record::resolveReferencesTo(const RecordVal *RV) {
for (unsigned i = 0, e = Values.size(); i != e; ++i) {
- if (const Init *V = Values[i].getValue())
+ if (Init *V = Values[i].getValue())
Values[i].setValue(V->resolveReferences(*this, RV));
}
}
@@ -1713,7 +1706,7 @@
/// getValueInit - Return the initializer for a value with the specified name,
/// or throw an exception if the field does not exist.
///
-const Init *Record::getValueInit(StringRef FieldName) const {
+Init *Record::getValueInit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
throw "Record `" + getName() + "' does not have a field named `" +
@@ -1732,7 +1725,7 @@
throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n";
- if (const StringInit *SI = dynamic_cast<const StringInit*>(R->getValue()))
+ if (StringInit *SI = dynamic_cast<StringInit*>(R->getValue()))
return SI->getValue();
throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a string initializer!";
@@ -1742,13 +1735,13 @@
/// its value as a BitsInit, throwing an exception if the field does not exist
/// or if the value is not the right type.
///
-const BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
+BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n";
- if (const BitsInit *BI = dynamic_cast<const BitsInit*>(R->getValue()))
+ if (BitsInit *BI = dynamic_cast<BitsInit*>(R->getValue()))
return BI;
throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a BitsInit initializer!";
@@ -1758,13 +1751,13 @@
/// its value as a ListInit, throwing an exception if the field does not exist
/// or if the value is not the right type.
///
-const ListInit *Record::getValueAsListInit(StringRef FieldName) const {
+ListInit *Record::getValueAsListInit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n";
- if (const ListInit *LI = dynamic_cast<const ListInit*>(R->getValue()))
+ if (ListInit *LI = dynamic_cast<ListInit*>(R->getValue()))
return LI;
throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a list initializer!";
@@ -1776,10 +1769,10 @@
///
std::vector<Record*>
Record::getValueAsListOfDefs(StringRef FieldName) const {
- const ListInit *List = getValueAsListInit(FieldName);
+ ListInit *List = getValueAsListInit(FieldName);
std::vector<Record*> Defs;
for (unsigned i = 0; i < List->getSize(); i++) {
- if (const DefInit *DI = dynamic_cast<const DefInit*>(List->getElement(i))) {
+ if (DefInit *DI = dynamic_cast<DefInit*>(List->getElement(i))) {
Defs.push_back(DI->getDef());
} else {
throw "Record `" + getName() + "', field `" + FieldName.str() +
@@ -1799,7 +1792,7 @@
throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n";
- if (const IntInit *II = dynamic_cast<const IntInit*>(R->getValue()))
+ if (IntInit *II = dynamic_cast<IntInit*>(R->getValue()))
return II->getValue();
throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have an int initializer!";
@@ -1811,10 +1804,10 @@
///
std::vector<int64_t>
Record::getValueAsListOfInts(StringRef FieldName) const {
- const ListInit *List = getValueAsListInit(FieldName);
+ ListInit *List = getValueAsListInit(FieldName);
std::vector<int64_t> Ints;
for (unsigned i = 0; i < List->getSize(); i++) {
- if (const IntInit *II = dynamic_cast<const IntInit*>(List->getElement(i))) {
+ if (IntInit *II = dynamic_cast<IntInit*>(List->getElement(i))) {
Ints.push_back(II->getValue());
} else {
throw "Record `" + getName() + "', field `" + FieldName.str() +
@@ -1830,10 +1823,10 @@
///
std::vector<std::string>
Record::getValueAsListOfStrings(StringRef FieldName) const {
- const ListInit *List = getValueAsListInit(FieldName);
+ ListInit *List = getValueAsListInit(FieldName);
std::vector<std::string> Strings;
for (unsigned i = 0; i < List->getSize(); i++) {
- if (const StringInit *II = dynamic_cast<const StringInit*>(List->getElement(i))) {
+ if (StringInit *II = dynamic_cast<StringInit*>(List->getElement(i))) {
Strings.push_back(II->getValue());
} else {
throw "Record `" + getName() + "', field `" + FieldName.str() +
@@ -1853,7 +1846,7 @@
throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n";
- if (const DefInit *DI = dynamic_cast<const DefInit*>(R->getValue()))
+ if (DefInit *DI = dynamic_cast<DefInit*>(R->getValue()))
return DI->getDef();
throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a def initializer!";
@@ -1869,7 +1862,7 @@
throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n";
- if (const BitInit *BI = dynamic_cast<const BitInit*>(R->getValue()))
+ if (BitInit *BI = dynamic_cast<BitInit*>(R->getValue()))
return BI->getValue();
throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a bit initializer!";
@@ -1879,13 +1872,13 @@
/// value as an Dag, throwing an exception if the field does not exist or if
/// the value is not the right type.
///
-const DagInit *Record::getValueAsDag(StringRef FieldName) const {
+DagInit *Record::getValueAsDag(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n";
- if (const DagInit *DI = dynamic_cast<const DagInit*>(R->getValue()))
+ if (DagInit *DI = dynamic_cast<DagInit*>(R->getValue()))
return DI;
throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a dag initializer!";
@@ -1897,7 +1890,7 @@
throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n";
- if (const CodeInit *CI = dynamic_cast<const CodeInit*>(R->getValue()))
+ if (CodeInit *CI = dynamic_cast<CodeInit*>(R->getValue()))
return CI->getValue();
throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a code initializer!";
Modified: llvm/trunk/utils/TableGen/Record.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/Record.h?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/Record.h (original)
+++ llvm/trunk/utils/TableGen/Record.h Fri Jul 29 17:43:06 2011
@@ -85,31 +85,31 @@
ListRecTy *getListTy();
public: // These methods should only be called from subclasses of Init
- virtual const Init *convertValue( const UnsetInit *UI) { return 0; }
- virtual const Init *convertValue( const BitInit *BI) { return 0; }
- virtual const Init *convertValue( const BitsInit *BI) { return 0; }
- virtual const Init *convertValue( const IntInit *II) { return 0; }
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue( const ListInit *LI) { return 0; }
- virtual const Init *convertValue( const UnOpInit *UI) {
- return convertValue((const TypedInit*)UI);
- }
- virtual const Init *convertValue( const BinOpInit *UI) {
- return convertValue((const TypedInit*)UI);
- }
- virtual const Init *convertValue( const TernOpInit *UI) {
- return convertValue((const TypedInit*)UI);
- }
- virtual const Init *convertValue( const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue( const DefInit *DI) { return 0; }
- virtual const Init *convertValue( const DagInit *DI) { return 0; }
- virtual const Init *convertValue( const TypedInit *TI) { return 0; }
- virtual const Init *convertValue( const VarInit *VI) {
- return convertValue((const TypedInit*)VI);
+ virtual Init *convertValue( UnsetInit *UI) { return 0; }
+ virtual Init *convertValue( BitInit *BI) { return 0; }
+ virtual Init *convertValue( BitsInit *BI) { return 0; }
+ virtual Init *convertValue( IntInit *II) { return 0; }
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( UnOpInit *UI) {
+ return convertValue((TypedInit*)UI);
+ }
+ virtual Init *convertValue( BinOpInit *UI) {
+ return convertValue((TypedInit*)UI);
+ }
+ virtual Init *convertValue( TernOpInit *UI) {
+ return convertValue((TypedInit*)UI);
+ }
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( TypedInit *TI) { return 0; }
+ virtual Init *convertValue( VarInit *VI) {
+ return convertValue((TypedInit*)VI);
}
- virtual const Init *convertValue( const FieldInit *FI) {
- return convertValue((const TypedInit*)FI);
+ virtual Init *convertValue( FieldInit *FI) {
+ return convertValue((TypedInit*)FI);
}
public: // These methods should only be called by subclasses of RecTy.
@@ -139,22 +139,22 @@
public:
static BitRecTy *get() { return &Shared; }
- virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
- virtual const Init *convertValue( const BitInit *BI) { return (const Init*)BI; }
- virtual const Init *convertValue( const BitsInit *BI);
- virtual const Init *convertValue( const IntInit *II);
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue( const ListInit *LI) { return 0; }
- virtual const Init *convertValue( const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return (const Init*)VB; }
- virtual const Init *convertValue( const DefInit *DI) { return 0; }
- virtual const Init *convertValue( const DagInit *DI) { return 0; }
- virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const TypedInit *TI);
- virtual const Init *convertValue( const VarInit *VI) { return RecTy::convertValue(VI);}
- virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+ virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+ virtual Init *convertValue( BitInit *BI) { return (Init*)BI; }
+ virtual Init *convertValue( BitsInit *BI);
+ virtual Init *convertValue( IntInit *II);
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return (Init*)VB; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TypedInit *TI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "bit"; }
@@ -184,22 +184,22 @@
unsigned getNumBits() const { return Size; }
- virtual const Init *convertValue( const UnsetInit *UI);
- virtual const Init *convertValue( const BitInit *UI);
- virtual const Init *convertValue( const BitsInit *BI);
- virtual const Init *convertValue( const IntInit *II);
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue( const ListInit *LI) { return 0; }
- virtual const Init *convertValue( const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue( const DefInit *DI) { return 0; }
- virtual const Init *convertValue( const DagInit *DI) { return 0; }
- virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const TypedInit *TI);
- virtual const Init *convertValue( const VarInit *VI) { return RecTy::convertValue(VI);}
- virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+ virtual Init *convertValue( UnsetInit *UI);
+ virtual Init *convertValue( BitInit *UI);
+ virtual Init *convertValue( BitsInit *BI);
+ virtual Init *convertValue( IntInit *II);
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TypedInit *TI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const;
@@ -228,22 +228,22 @@
public:
static IntRecTy *get() { return &Shared; }
- virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
- virtual const Init *convertValue( const BitInit *BI);
- virtual const Init *convertValue( const BitsInit *BI);
- virtual const Init *convertValue( const IntInit *II) { return (const Init*)II; }
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue( const ListInit *LI) { return 0; }
- virtual const Init *convertValue( const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue( const DefInit *DI) { return 0; }
- virtual const Init *convertValue( const DagInit *DI) { return 0; }
- virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const TypedInit *TI);
- virtual const Init *convertValue( const VarInit *VI) { return RecTy::convertValue(VI);}
- virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+ virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+ virtual Init *convertValue( BitInit *BI);
+ virtual Init *convertValue( BitsInit *BI);
+ virtual Init *convertValue( IntInit *II) { return (Init*)II; }
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TypedInit *TI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "int"; }
@@ -270,23 +270,23 @@
public:
static StringRecTy *get() { return &Shared; }
- virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
- virtual const Init *convertValue( const BitInit *BI) { return 0; }
- virtual const Init *convertValue( const BitsInit *BI) { return 0; }
- virtual const Init *convertValue( const IntInit *II) { return 0; }
- virtual const Init *convertValue(const StringInit *SI) { return (const Init*)SI; }
- virtual const Init *convertValue( const ListInit *LI) { return 0; }
- virtual const Init *convertValue( const UnOpInit *BO);
- virtual const Init *convertValue( const BinOpInit *BO);
- virtual const Init *convertValue( const TernOpInit *BO) { return RecTy::convertValue(BO);}
-
- virtual const Init *convertValue( const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue( const DefInit *DI) { return 0; }
- virtual const Init *convertValue( const DagInit *DI) { return 0; }
- virtual const Init *convertValue( const TypedInit *TI);
- virtual const Init *convertValue( const VarInit *VI) { return RecTy::convertValue(VI);}
- virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+ virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+ virtual Init *convertValue( BitInit *BI) { return 0; }
+ virtual Init *convertValue( BitsInit *BI) { return 0; }
+ virtual Init *convertValue( IntInit *II) { return 0; }
+ virtual Init *convertValue(StringInit *SI) { return (Init*)SI; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( UnOpInit *BO);
+ virtual Init *convertValue( BinOpInit *BO);
+ virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);}
+
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( TypedInit *TI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "string"; }
@@ -317,22 +317,22 @@
static ListRecTy *get(RecTy *T) { return T->getListTy(); }
RecTy *getElementType() const { return Ty; }
- virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
- virtual const Init *convertValue( const BitInit *BI) { return 0; }
- virtual const Init *convertValue( const BitsInit *BI) { return 0; }
- virtual const Init *convertValue( const IntInit *II) { return 0; }
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue( const ListInit *LI);
- virtual const Init *convertValue( const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue( const DefInit *DI) { return 0; }
- virtual const Init *convertValue( const DagInit *DI) { return 0; }
- virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const TypedInit *TI);
- virtual const Init *convertValue( const VarInit *VI) { return RecTy::convertValue(VI);}
- virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+ virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+ virtual Init *convertValue( BitInit *BI) { return 0; }
+ virtual Init *convertValue( BitsInit *BI) { return 0; }
+ virtual Init *convertValue( IntInit *II) { return 0; }
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI);
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TypedInit *TI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const;
@@ -360,22 +360,22 @@
public:
static CodeRecTy *get() { return &Shared; }
- virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
- virtual const Init *convertValue( const BitInit *BI) { return 0; }
- virtual const Init *convertValue( const BitsInit *BI) { return 0; }
- virtual const Init *convertValue( const IntInit *II) { return 0; }
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue( const ListInit *LI) { return 0; }
- virtual const Init *convertValue( const CodeInit *CI) { return (const Init*)CI; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue( const DefInit *DI) { return 0; }
- virtual const Init *convertValue( const DagInit *DI) { return 0; }
- virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const TypedInit *TI);
- virtual const Init *convertValue( const VarInit *VI) { return RecTy::convertValue(VI);}
- virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+ virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+ virtual Init *convertValue( BitInit *BI) { return 0; }
+ virtual Init *convertValue( BitsInit *BI) { return 0; }
+ virtual Init *convertValue( IntInit *II) { return 0; }
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( CodeInit *CI) { return (Init*)CI; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TypedInit *TI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "code"; }
@@ -400,22 +400,22 @@
public:
static DagRecTy *get() { return &Shared; }
- virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
- virtual const Init *convertValue( const BitInit *BI) { return 0; }
- virtual const Init *convertValue( const BitsInit *BI) { return 0; }
- virtual const Init *convertValue( const IntInit *II) { return 0; }
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue( const ListInit *LI) { return 0; }
- virtual const Init *convertValue( const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue( const DefInit *DI) { return 0; }
- virtual const Init *convertValue( const UnOpInit *BO);
- virtual const Init *convertValue( const BinOpInit *BO);
- virtual const Init *convertValue( const TernOpInit *BO) { return RecTy::convertValue(BO);}
- virtual const Init *convertValue( const DagInit *CI) { return (const Init*)CI; }
- virtual const Init *convertValue( const TypedInit *TI);
- virtual const Init *convertValue( const VarInit *VI) { return RecTy::convertValue(VI);}
- virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+ virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+ virtual Init *convertValue( BitInit *BI) { return 0; }
+ virtual Init *convertValue( BitsInit *BI) { return 0; }
+ virtual Init *convertValue( IntInit *II) { return 0; }
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( UnOpInit *BO);
+ virtual Init *convertValue( BinOpInit *BO);
+ virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);}
+ virtual Init *convertValue( DagInit *CI) { return (Init*)CI; }
+ virtual Init *convertValue( TypedInit *TI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "dag"; }
@@ -446,22 +446,22 @@
Record *getRecord() const { return Rec; }
- virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
- virtual const Init *convertValue( const BitInit *BI) { return 0; }
- virtual const Init *convertValue( const BitsInit *BI) { return 0; }
- virtual const Init *convertValue( const IntInit *II) { return 0; }
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue( const ListInit *LI) { return 0; }
- virtual const Init *convertValue( const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
- virtual const Init *convertValue( const DefInit *DI);
- virtual const Init *convertValue( const DagInit *DI) { return 0; }
- virtual const Init *convertValue( const TypedInit *VI);
- virtual const Init *convertValue( const VarInit *VI) { return RecTy::convertValue(VI);}
- virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
+ virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+ virtual Init *convertValue( BitInit *BI) { return 0; }
+ virtual Init *convertValue( BitsInit *BI) { return 0; }
+ virtual Init *convertValue( IntInit *II) { return 0; }
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( DefInit *DI);
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( TypedInit *VI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const;
@@ -515,14 +515,14 @@
/// function that should be overridden to call the appropriate
/// RecTy::convertValue method.
///
- virtual const Init *convertInitializerTo(RecTy *Ty) const = 0;
+ virtual Init *convertInitializerTo(RecTy *Ty) const = 0;
/// convertInitializerBitRange - This method is used to implement the bitrange
/// selection operator. Given an initializer, it selects the specified bits
/// out, returning them as a new init of bits type. If it is not legal to use
/// the bit subscript operator on this initializer, return null.
///
- virtual const Init *
+ virtual Init *
convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
return 0;
}
@@ -532,7 +532,7 @@
/// elements, returning them as a new init of list type. If it is not legal
/// to take a slice of this, return null.
///
- virtual const Init *
+ virtual Init *
convertInitListSlice(const std::vector<unsigned> &Elements) const {
return 0;
}
@@ -547,8 +547,8 @@
/// initializer for the specified field. If getFieldType returns non-null
/// this method should return non-null, otherwise it returns null.
///
- virtual const Init *getFieldInit(Record &R, const RecordVal *RV,
- const std::string &FieldName) const {
+ virtual Init *getFieldInit(Record &R, const RecordVal *RV,
+ const std::string &FieldName) const {
return 0;
}
@@ -557,8 +557,8 @@
/// If a value is set for the variable later, this method will be called on
/// users of the value to allow the value to propagate out.
///
- virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const {
- return this;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV) const {
+ return const_cast<Init *>(this);
}
};
@@ -581,9 +581,9 @@
public:
RecTy *getType() const { return Ty; }
- virtual const Init *
+ virtual Init *
convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
- virtual const Init *
+ virtual Init *
convertInitListSlice(const std::vector<unsigned> &Elements) const;
/// getFieldType - This method is used to implement the FieldInit class.
@@ -596,14 +596,14 @@
/// VarBitInit::resolveReferences. If the bit is able to be resolved, we
/// simply return the resolved value, otherwise we return null.
///
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const = 0;
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const = 0;
/// resolveListElementReference - This method is used to implement
/// VarListElementInit::resolveReferences. If the list element is resolvable
/// now, we return the resolved value, otherwise we return null.
- virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
- unsigned Elt) const = 0;
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) const = 0;
};
@@ -615,10 +615,10 @@
UnsetInit &operator=(const UnsetInit &Other); // Do not define.
public:
- static const UnsetInit *get();
+ static UnsetInit *get();
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
- return Ty->convertValue(this);
+ virtual Init *convertInitializerTo(RecTy *Ty) const {
+ return Ty->convertValue(const_cast<UnsetInit *>(this));
}
virtual bool isComplete() const { return false; }
@@ -636,12 +636,12 @@
BitInit &operator=(BitInit &Other); // Do not define.
public:
- static const BitInit *get(bool V);
+ static BitInit *get(bool V);
bool getValue() const { return Value; }
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
- return Ty->convertValue(this);
+ virtual Init *convertInitializerTo(RecTy *Ty) const {
+ return Ty->convertValue(const_cast<BitInit *>(this));
}
virtual std::string getAsString() const { return Value ? "1" : "0"; }
@@ -651,29 +651,29 @@
/// It contains a vector of bits, whose size is determined by the type.
///
class BitsInit : public Init, public FoldingSetNode {
- std::vector<const Init*> Bits;
+ std::vector<Init*> Bits;
- BitsInit(ArrayRef<const Init *> Range) : Bits(Range.begin(), Range.end()) {}
+ BitsInit(ArrayRef<Init *> Range) : Bits(Range.begin(), Range.end()) {}
BitsInit(const BitsInit &Other); // Do not define.
BitsInit &operator=(const BitsInit &Other); // Do not define.
public:
- static const BitsInit *get(ArrayRef<const Init *> Range);
+ static BitsInit *get(ArrayRef<Init *> Range);
void Profile(FoldingSetNodeID &ID) const;
unsigned getNumBits() const { return Bits.size(); }
- const Init *getBit(unsigned Bit) const {
+ Init *getBit(unsigned Bit) const {
assert(Bit < Bits.size() && "Bit index out of range!");
return Bits[Bit];
}
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
- return Ty->convertValue(this);
+ virtual Init *convertInitializerTo(RecTy *Ty) const {
+ return Ty->convertValue(const_cast<BitsInit *>(this));
}
- virtual const Init *
+ virtual Init *
convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
virtual bool isComplete() const {
@@ -688,7 +688,7 @@
}
virtual std::string getAsString() const;
- virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
};
@@ -703,14 +703,14 @@
IntInit &operator=(const IntInit &Other); // Do note define.
public:
- static const IntInit *get(int64_t V);
+ static IntInit *get(int64_t V);
int64_t getValue() const { return Value; }
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
- return Ty->convertValue(this);
+ virtual Init *convertInitializerTo(RecTy *Ty) const {
+ return Ty->convertValue(const_cast<IntInit *>(this));
}
- virtual const Init *
+ virtual Init *
convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
virtual std::string getAsString() const;
@@ -719,8 +719,8 @@
/// VarBitInit::resolveReferences. If the bit is able to be resolved, we
/// simply return the resolved value, otherwise we return null.
///
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const {
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const {
assert(0 && "Illegal bit reference off int");
return 0;
}
@@ -728,8 +728,8 @@
/// resolveListElementReference - This method is used to implement
/// VarListElementInit::resolveReferences. If the list element is resolvable
/// now, we return the resolved value, otherwise we return null.
- virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
- unsigned Elt) const {
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) const {
assert(0 && "Illegal element reference off int");
return 0;
}
@@ -748,12 +748,12 @@
StringInit &operator=(const StringInit &Other); // Do not define.
public:
- static const StringInit *get(const std::string &V);
+ static StringInit *get(const std::string &V);
const std::string &getValue() const { return Value; }
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
- return Ty->convertValue(this);
+ virtual Init *convertInitializerTo(RecTy *Ty) const {
+ return Ty->convertValue(const_cast<StringInit *>(this));
}
virtual std::string getAsString() const { return "\"" + Value + "\""; }
@@ -762,8 +762,8 @@
/// VarBitInit::resolveReferences. If the bit is able to be resolved, we
/// simply return the resolved value, otherwise we return null.
///
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const {
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const {
assert(0 && "Illegal bit reference off string");
return 0;
}
@@ -771,8 +771,8 @@
/// resolveListElementReference - This method is used to implement
/// VarListElementInit::resolveReferences. If the list element is resolvable
/// now, we return the resolved value, otherwise we return null.
- virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
- unsigned Elt) const {
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) const {
assert(0 && "Illegal element reference off string");
return 0;
}
@@ -789,12 +789,12 @@
CodeInit &operator=(const CodeInit &Other); // Do not define.
public:
- static const CodeInit *get(const std::string &V);
+ static CodeInit *get(const std::string &V);
const std::string &getValue() const { return Value; }
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
- return Ty->convertValue(this);
+ virtual Init *convertInitializerTo(RecTy *Ty) const {
+ return Ty->convertValue(const_cast<CodeInit *>(this));
}
virtual std::string getAsString() const { return "[{" + Value + "}]"; }
@@ -803,34 +803,34 @@
/// ListInit - [AL, AH, CL] - Represent a list of defs
///
class ListInit : public TypedInit, public FoldingSetNode {
- std::vector<const Init*> Values;
+ std::vector<Init*> Values;
public:
- typedef std::vector<const Init*>::const_iterator const_iterator;
+ typedef std::vector<Init*>::const_iterator const_iterator;
private:
- explicit ListInit(ArrayRef<const Init *> Range, RecTy *EltTy)
+ explicit ListInit(ArrayRef<Init *> Range, RecTy *EltTy)
: TypedInit(ListRecTy::get(EltTy)), Values(Range.begin(), Range.end()) {}
ListInit(const ListInit &Other); // Do not define.
ListInit &operator=(const ListInit &Other); // Do not define.
public:
- static const ListInit *get(ArrayRef<const Init *> Range, RecTy *EltTy);
+ static ListInit *get(ArrayRef<Init *> Range, RecTy *EltTy);
void Profile(FoldingSetNodeID &ID) const;
unsigned getSize() const { return Values.size(); }
- const Init *getElement(unsigned i) const {
+ Init *getElement(unsigned i) const {
assert(i < Values.size() && "List element index out of range!");
return Values[i];
}
Record *getElementAsRecord(unsigned i) const;
- const Init *convertInitListSlice(const std::vector<unsigned> &Elements) const;
+ Init *convertInitListSlice(const std::vector<unsigned> &Elements) const;
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
- return Ty->convertValue(this);
+ virtual Init *convertInitializerTo(RecTy *Ty) const {
+ return Ty->convertValue(const_cast<ListInit *>(this));
}
/// resolveReferences - This method is used by classes that refer to other
@@ -838,11 +838,11 @@
/// If a value is set for the variable later, this method will be called on
/// users of the value to allow the value to propagate out.
///
- virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
virtual std::string getAsString() const;
- ArrayRef<const Init*> getValues() const { return Values; }
+ ArrayRef<Init*> getValues() const { return Values; }
inline const_iterator begin() const { return Values.begin(); }
inline const_iterator end () const { return Values.end(); }
@@ -854,8 +854,8 @@
/// VarBitInit::resolveReferences. If the bit is able to be resolved, we
/// simply return the resolved value, otherwise we return null.
///
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const {
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const {
assert(0 && "Illegal bit reference off list");
return 0;
}
@@ -863,8 +863,8 @@
/// resolveListElementReference - This method is used to implement
/// VarListElementInit::resolveReferences. If the list element is resolvable
/// now, we return the resolved value, otherwise we return null.
- virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
- unsigned Elt) const;
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) const;
};
@@ -879,24 +879,23 @@
public:
// Clone - Clone this operator, replacing arguments with the new list
- virtual const OpInit *clone(std::vector<const Init *> &Operands) const = 0;
+ virtual OpInit *clone(std::vector<Init *> &Operands) const = 0;
virtual int getNumOperands() const = 0;
- virtual const Init *getOperand(int i) const = 0;
+ virtual Init *getOperand(int i) const = 0;
// Fold - If possible, fold this to a simpler init. Return this if not
// possible to fold.
- virtual const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0;
+ virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0;
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
- return Ty->convertValue(this);
+ virtual Init *convertInitializerTo(RecTy *Ty) const {
+ return Ty->convertValue(const_cast<OpInit *>(this));
}
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const;
- virtual const Init *resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const;
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const;
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) const;
};
@@ -907,38 +906,38 @@
enum UnaryOp { CAST, HEAD, TAIL, EMPTY };
private:
UnaryOp Opc;
- const Init *LHS;
+ Init *LHS;
- UnOpInit(UnaryOp opc, const Init *lhs, RecTy *Type)
+ UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
: OpInit(Type), Opc(opc), LHS(lhs) {}
UnOpInit(const UnOpInit &Other); // Do not define.
UnOpInit &operator=(const UnOpInit &Other); // Do not define.
public:
- static const UnOpInit *get(UnaryOp opc, const Init *lhs, RecTy *Type);
+ static UnOpInit *get(UnaryOp opc, Init *lhs, RecTy *Type);
// Clone - Clone this operator, replacing arguments with the new list
- virtual const OpInit *clone(std::vector<const Init *> &Operands) const {
+ virtual OpInit *clone(std::vector<Init *> &Operands) const {
assert(Operands.size() == 1 &&
"Wrong number of operands for unary operation");
return UnOpInit::get(getOpcode(), *Operands.begin(), getType());
}
int getNumOperands() const { return 1; }
- const Init *getOperand(int i) const {
+ Init *getOperand(int i) const {
assert(i == 0 && "Invalid operand id for unary operator");
return getOperand();
}
UnaryOp getOpcode() const { return Opc; }
- const Init *getOperand() const { return LHS; }
+ Init *getOperand() const { return LHS; }
// Fold - If possible, fold this to a simpler init. Return this if not
// possible to fold.
- const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
+ Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
- virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
virtual std::string getAsString() const;
};
@@ -950,27 +949,27 @@
enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, EQ };
private:
BinaryOp Opc;
- const Init *LHS, *RHS;
+ Init *LHS, *RHS;
- BinOpInit(BinaryOp opc, const Init *lhs, const Init *rhs, RecTy *Type) :
+ BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
OpInit(Type), Opc(opc), LHS(lhs), RHS(rhs) {}
BinOpInit(const BinOpInit &Other); // Do not define.
BinOpInit &operator=(const BinOpInit &Other); // Do not define.
public:
- static const BinOpInit *get(BinaryOp opc, const Init *lhs, const Init *rhs,
- RecTy *Type);
+ static BinOpInit *get(BinaryOp opc, Init *lhs, Init *rhs,
+ RecTy *Type);
// Clone - Clone this operator, replacing arguments with the new list
- virtual const OpInit *clone(std::vector<const Init *> &Operands) const {
+ virtual OpInit *clone(std::vector<Init *> &Operands) const {
assert(Operands.size() == 2 &&
"Wrong number of operands for binary operation");
return BinOpInit::get(getOpcode(), Operands[0], Operands[1], getType());
}
int getNumOperands() const { return 2; }
- const Init *getOperand(int i) const {
+ Init *getOperand(int i) const {
assert((i == 0 || i == 1) && "Invalid operand id for binary operator");
if (i == 0) {
return getLHS();
@@ -980,14 +979,14 @@
}
BinaryOp getOpcode() const { return Opc; }
- const Init *getLHS() const { return LHS; }
- const Init *getRHS() const { return RHS; }
+ Init *getLHS() const { return LHS; }
+ Init *getRHS() const { return RHS; }
// Fold - If possible, fold this to a simpler init. Return this if not
// possible to fold.
- const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
+ Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
- virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
virtual std::string getAsString() const;
};
@@ -999,9 +998,9 @@
enum TernaryOp { SUBST, FOREACH, IF };
private:
TernaryOp Opc;
- const Init *LHS, *MHS, *RHS;
+ Init *LHS, *MHS, *RHS;
- TernOpInit(TernaryOp opc, const Init *lhs, const Init *mhs, const Init *rhs,
+ TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs,
RecTy *Type) :
OpInit(Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) {}
@@ -1009,12 +1008,12 @@
TernOpInit &operator=(const TernOpInit &Other); // Do not define.
public:
- static const TernOpInit *get(TernaryOp opc, const Init *lhs,
- const Init *mhs, const Init *rhs,
- RecTy *Type);
+ static TernOpInit *get(TernaryOp opc, Init *lhs,
+ Init *mhs, Init *rhs,
+ RecTy *Type);
// Clone - Clone this operator, replacing arguments with the new list
- virtual const OpInit *clone(std::vector<const Init *> &Operands) const {
+ virtual OpInit *clone(std::vector<Init *> &Operands) const {
assert(Operands.size() == 3 &&
"Wrong number of operands for ternary operation");
return TernOpInit::get(getOpcode(), Operands[0], Operands[1], Operands[2],
@@ -1022,7 +1021,7 @@
}
int getNumOperands() const { return 3; }
- const Init *getOperand(int i) const {
+ Init *getOperand(int i) const {
assert((i == 0 || i == 1 || i == 2) &&
"Invalid operand id for ternary operator");
if (i == 0) {
@@ -1035,17 +1034,17 @@
}
TernaryOp getOpcode() const { return Opc; }
- const Init *getLHS() const { return LHS; }
- const Init *getMHS() const { return MHS; }
- const Init *getRHS() const { return RHS; }
+ Init *getLHS() const { return LHS; }
+ Init *getMHS() const { return MHS; }
+ Init *getRHS() const { return RHS; }
// Fold - If possible, fold this to a simpler init. Return this if not
// possible to fold.
- const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
+ Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
virtual bool isComplete() const { return false; }
- virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
virtual std::string getAsString() const;
};
@@ -1063,30 +1062,30 @@
VarInit &operator=(const VarInit &Other); // Do not define.
public:
- static const VarInit *get(const std::string &VN, RecTy *T);
- static const VarInit *get(const Init *VN, RecTy *T);
+ static VarInit *get(const std::string &VN, RecTy *T);
+ static VarInit *get(Init *VN, RecTy *T);
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
- return Ty->convertValue(this);
+ virtual Init *convertInitializerTo(RecTy *Ty) const {
+ return Ty->convertValue(const_cast<VarInit *>(this));
}
const std::string &getName() const { return VarName; }
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const;
- virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
- unsigned Elt) const;
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const;
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) const;
virtual RecTy *getFieldType(const std::string &FieldName) const;
- virtual const Init *getFieldInit(Record &R, const RecordVal *RV,
- const std::string &FieldName) const;
+ virtual Init *getFieldInit(Record &R, const RecordVal *RV,
+ const std::string &FieldName) const;
/// resolveReferences - This method is used by classes that refer to other
/// variables which may not be defined at the time they expression is formed.
/// If a value is set for the variable later, this method will be called on
/// users of the value to allow the value to propagate out.
///
- virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
virtual std::string getAsString() const { return VarName; }
};
@@ -1095,10 +1094,10 @@
/// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field.
///
class VarBitInit : public Init {
- const TypedInit *TI;
+ TypedInit *TI;
unsigned Bit;
- VarBitInit(const TypedInit *T, unsigned B) : TI(T), Bit(B) {
+ VarBitInit(TypedInit *T, unsigned B) : TI(T), Bit(B) {
assert(T->getType() && dynamic_cast<BitsRecTy*>(T->getType()) &&
((BitsRecTy*)T->getType())->getNumBits() > B &&
"Illegal VarBitInit expression!");
@@ -1108,26 +1107,26 @@
VarBitInit &operator=(const VarBitInit &Other); // Do not define.
public:
- static const VarBitInit *get(const TypedInit *T, unsigned B);
+ static VarBitInit *get(TypedInit *T, unsigned B);
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
- return Ty->convertValue(this);
+ virtual Init *convertInitializerTo(RecTy *Ty) const {
+ return Ty->convertValue(const_cast<VarBitInit *>(this));
}
- const TypedInit *getVariable() const { return TI; }
+ TypedInit *getVariable() const { return TI; }
unsigned getBitNum() const { return Bit; }
virtual std::string getAsString() const;
- virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
};
/// VarListElementInit - List[4] - Represent access to one element of a var or
/// field.
class VarListElementInit : public TypedInit {
- const TypedInit *TI;
+ TypedInit *TI;
unsigned Element;
- VarListElementInit(const TypedInit *T, unsigned E)
+ VarListElementInit(TypedInit *T, unsigned E)
: TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()),
TI(T), Element(E) {
assert(T->getType() && dynamic_cast<ListRecTy*>(T->getType()) &&
@@ -1140,27 +1139,27 @@
// define.
public:
- static const VarListElementInit *get(const TypedInit *T, unsigned E);
+ static VarListElementInit *get(TypedInit *T, unsigned E);
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
- return Ty->convertValue(this);
+ virtual Init *convertInitializerTo(RecTy *Ty) const {
+ return Ty->convertValue(const_cast<VarListElementInit *>(this));
}
- const TypedInit *getVariable() const { return TI; }
+ TypedInit *getVariable() const { return TI; }
unsigned getElementNum() const { return Element; }
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const;
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const;
/// resolveListElementReference - This method is used to implement
/// VarListElementInit::resolveReferences. If the list element is resolvable
/// now, we return the resolved value, otherwise we return null.
- virtual const Init *resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const;
+ virtual Init *resolveListElementReference(Record &R,
+ const RecordVal *RV,
+ unsigned Elt) const;
virtual std::string getAsString() const;
- virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
};
/// DefInit - AL - Represent a reference to a 'def' in the description
@@ -1175,20 +1174,19 @@
DefInit &operator=(const DefInit &Other); // Do not define.
public:
- static const DefInit *get(Record*);
+ static DefInit *get(Record*);
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
- return Ty->convertValue(this);
+ virtual Init *convertInitializerTo(RecTy *Ty) const {
+ return Ty->convertValue(const_cast<DefInit *>(this));
}
Record *getDef() const { return Def; }
- //virtual const Init *
- //convertInitializerBitRange(const std::vector<unsigned> &Bits);
+ //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
virtual RecTy *getFieldType(const std::string &FieldName) const;
- virtual const Init *getFieldInit(Record &R, const RecordVal *RV,
- const std::string &FieldName) const;
+ virtual Init *getFieldInit(Record &R, const RecordVal *RV,
+ const std::string &FieldName) const;
virtual std::string getAsString() const;
@@ -1196,8 +1194,8 @@
/// VarBitInit::resolveReferences. If the bit is able to be resolved, we
/// simply return the resolved value, otherwise we return null.
///
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const {
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const {
assert(0 && "Illegal bit reference off def");
return 0;
}
@@ -1205,8 +1203,8 @@
/// resolveListElementReference - This method is used to implement
/// VarListElementInit::resolveReferences. If the list element is resolvable
/// now, we return the resolved value, otherwise we return null.
- virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
- unsigned Elt) const {
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) const {
assert(0 && "Illegal element reference off def");
return 0;
}
@@ -1216,10 +1214,10 @@
/// FieldInit - X.Y - Represent a reference to a subfield of a variable
///
class FieldInit : public TypedInit {
- const Init *Rec; // Record we are referring to
+ Init *Rec; // Record we are referring to
std::string FieldName; // Field we are accessing
- FieldInit(const Init *R, const std::string &FN)
+ FieldInit(Init *R, const std::string &FN)
: TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) {
assert(getType() && "FieldInit with non-record type!");
}
@@ -1228,20 +1226,20 @@
FieldInit &operator=(const FieldInit &Other); // Do not define.
public:
- static const FieldInit *get(const Init *R, const std::string &FN);
- static const FieldInit *get(const Init *R, const Init *FN);
+ static FieldInit *get(Init *R, const std::string &FN);
+ static FieldInit *get(Init *R, const Init *FN);
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
- return Ty->convertValue(this);
+ virtual Init *convertInitializerTo(RecTy *Ty) const {
+ return Ty->convertValue(const_cast<FieldInit *>(this));
}
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const;
- virtual const Init *resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const;
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const;
+ virtual Init *resolveListElementReference(Record &R,
+ const RecordVal *RV,
+ unsigned Elt) const;
- virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
virtual std::string getAsString() const {
return Rec->getAsString() + "." + FieldName;
@@ -1253,13 +1251,13 @@
/// argument can have a name associated with it.
///
class DagInit : public TypedInit, public FoldingSetNode {
- const Init *Val;
+ Init *Val;
std::string ValName;
- std::vector<const Init*> Args;
+ std::vector<Init*> Args;
std::vector<std::string> ArgNames;
- DagInit(const Init *V, const std::string &VN,
- ArrayRef<const Init *> ArgRange,
+ DagInit(Init *V, const std::string &VN,
+ ArrayRef<Init *> ArgRange,
ArrayRef<std::string> NameRange)
: TypedInit(DagRecTy::get()), Val(V), ValName(VN),
Args(ArgRange.begin(), ArgRange.end()),
@@ -1269,25 +1267,25 @@
DagInit &operator=(const DagInit &Other); // Do not define.
public:
- static const DagInit *get(const Init *V, const std::string &VN,
- ArrayRef<const Init *> ArgRange,
- ArrayRef<std::string> NameRange);
- static const DagInit *get(const Init *V, const std::string &VN,
- const std::vector<
- std::pair<const Init*, std::string> > &args);
+ static DagInit *get(Init *V, const std::string &VN,
+ ArrayRef<Init *> ArgRange,
+ ArrayRef<std::string> NameRange);
+ static DagInit *get(Init *V, const std::string &VN,
+ const std::vector<
+ std::pair<Init*, std::string> > &args);
void Profile(FoldingSetNodeID &ID) const;
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
- return Ty->convertValue(this);
+ virtual Init *convertInitializerTo(RecTy *Ty) const {
+ return Ty->convertValue(const_cast<DagInit *>(this));
}
- const Init *getOperator() const { return Val; }
+ Init *getOperator() const { return Val; }
const std::string &getName() const { return ValName; }
unsigned getNumArgs() const { return Args.size(); }
- const Init *getArg(unsigned Num) const {
+ Init *getArg(unsigned Num) const {
assert(Num < Args.size() && "Arg number out of range!");
return Args[Num];
}
@@ -1296,11 +1294,11 @@
return ArgNames[Num];
}
- virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV) const;
virtual std::string getAsString() const;
- typedef std::vector<const Init*>::const_iterator const_arg_iterator;
+ typedef std::vector<Init*>::const_iterator const_arg_iterator;
typedef std::vector<std::string>::const_iterator const_name_iterator;
inline const_arg_iterator arg_begin() const { return Args.begin(); }
@@ -1315,15 +1313,14 @@
inline size_t name_size () const { return ArgNames.size(); }
inline bool name_empty() const { return ArgNames.empty(); }
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const {
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const {
assert(0 && "Illegal bit reference off dag");
return 0;
}
- virtual const Init *resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const {
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) const {
assert(0 && "Illegal element reference off dag");
return 0;
}
@@ -1337,7 +1334,7 @@
std::string Name;
RecTy *Ty;
unsigned Prefix;
- const Init *Value;
+ Init *Value;
public:
RecordVal(const std::string &N, RecTy *T, unsigned P);
@@ -1345,9 +1342,9 @@
unsigned getPrefix() const { return Prefix; }
RecTy *getType() const { return Ty; }
- const Init *getValue() const { return Value; }
+ Init *getValue() const { return Value; }
- bool setValue(const Init *V) {
+ bool setValue(Init *V) {
if (V) {
Value = V->convertInitializerTo(Ty);
return Value == 0;
@@ -1486,7 +1483,7 @@
/// getValueInit - Return the initializer for a value with the specified name,
/// or throw an exception if the field does not exist.
///
- const Init *getValueInit(StringRef FieldName) const;
+ Init *getValueInit(StringRef FieldName) const;
/// getValueAsString - This method looks up the specified field and returns
/// its value as a string, throwing an exception if the field does not exist
@@ -1498,13 +1495,13 @@
/// its value as a BitsInit, throwing an exception if the field does not exist
/// or if the value is not the right type.
///
- const BitsInit *getValueAsBitsInit(StringRef FieldName) const;
+ BitsInit *getValueAsBitsInit(StringRef FieldName) const;
/// getValueAsListInit - This method looks up the specified field and returns
/// its value as a ListInit, throwing an exception if the field does not exist
/// or if the value is not the right type.
///
- const ListInit *getValueAsListInit(StringRef FieldName) const;
+ ListInit *getValueAsListInit(StringRef FieldName) const;
/// getValueAsListOfDefs - This method looks up the specified field and
/// returns its value as a vector of records, throwing an exception if the
@@ -1546,7 +1543,7 @@
/// value as an Dag, throwing an exception if the field does not exist or if
/// the value is not the right type.
///
- const DagInit *getValueAsDag(StringRef FieldName) const;
+ DagInit *getValueAsDag(StringRef FieldName) const;
/// getValueAsCode - This method looks up the specified field and returns
/// its value as the string data in a CodeInit, throwing an exception if the
Modified: llvm/trunk/utils/TableGen/RegisterInfoEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/RegisterInfoEmitter.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/RegisterInfoEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/RegisterInfoEmitter.cpp Fri Jul 29 17:43:06 2011
@@ -166,7 +166,7 @@
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];
}
Modified: llvm/trunk/utils/TableGen/SetTheory.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/SetTheory.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/SetTheory.cpp (original)
+++ llvm/trunk/utils/TableGen/SetTheory.cpp Fri Jul 29 17:43:06 2011
@@ -27,14 +27,14 @@
// (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 @@
// (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 @@
// 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 @@
// (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 @@
// (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 @@
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 @@
// (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,25 +141,25 @@
// (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();
@@ -167,7 +167,7 @@
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) {
@@ -222,9 +222,9 @@
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());
@@ -232,14 +232,14 @@
}
// 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());
Modified: llvm/trunk/utils/TableGen/SetTheory.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/SetTheory.h?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/SetTheory.h (original)
+++ llvm/trunk/utils/TableGen/SetTheory.h Fri Jul 29 17:43:06 2011
@@ -70,7 +70,7 @@
/// 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 @@
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>
Modified: llvm/trunk/utils/TableGen/TGParser.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/TGParser.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/TGParser.cpp (original)
+++ llvm/trunk/utils/TableGen/TGParser.cpp Fri Jul 29 17:43:06 2011
@@ -28,7 +28,7 @@
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 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 @@
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 @@
/// 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 @@
// 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,22 +101,22 @@
// 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(BitsRecTy::get(BitList.size()));
+ Init *BI = V->convertInitializerTo(BitsRecTy::get(BitList.size()));
if (BI == 0) {
V->convertInitializerTo(BitsRecTy::get(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());
+ SmallVector<Init *, 16> NewBits(CurVal->getNumBits());
// Loop over bits, assigning values as appropriate.
for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
@@ -633,7 +633,7 @@
/// 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,7 +643,7 @@
/// 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))
@@ -677,7 +677,7 @@
///
/// 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 @@
}
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 @@
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;
@@ -825,7 +825,7 @@
}
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,7 +847,7 @@
// shorthand for nesting them.
if (Code == BinOpInit::STRCONCAT) {
while (InitList.size() > 2) {
- const Init *RHS = InitList.pop_back_val();
+ Init *RHS = InitList.pop_back_val();
RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))
->Fold(CurRec, CurMultiClass);
InitList.back() = RHS;
@@ -888,7 +888,7 @@
}
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 @@
}
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 @@
}
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 @@
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 = BitRecTy::get();
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 = BitRecTy::get();
@@ -964,7 +964,7 @@
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 @@
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;
@@ -1038,8 +1038,8 @@
/// 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;
@@ -1085,7 +1085,7 @@
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) {
@@ -1115,7 +1115,7 @@
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,10 +1127,10 @@
}
Lex.Lex(); // eat the '}'
- SmallVector<const Init *, 16> NewBits(Vals.size());
+ SmallVector<Init *, 16> NewBits(Vals.size());
for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
- const Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get());
+ Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get());
if (Bit == 0) {
Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+
") is not convertable to a bit");
@@ -1142,7 +1142,7 @@
}
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 +1190,10 @@
// 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;
@@ -1246,7 +1246,7 @@
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 +1260,7 @@
Lex.Lex(); // eat the VarName.
}
- std::vector<std::pair<const llvm::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;
@@ -1302,8 +1302,8 @@
/// 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.
@@ -1373,20 +1373,20 @@
///
/// ParseDagArgList ::= Value (':' VARNAME)?
/// ParseDagArgList ::= ParseDagArgList ',' Value (':' VARNAME)?
-std::vector<std::pair<const llvm::Init*, std::string> >
+std::vector<std::pair<llvm::Init*, std::string> >
TGParser::ParseDagArgList(Record *CurRec) {
- std::vector<std::pair<const llvm::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 llvm::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 llvm::Init*, std::string> >();
+ return std::vector<std::pair<llvm::Init*, std::string> >();
}
VarName = Lex.getCurStrVal();
Lex.Lex(); // eat the VarName.
@@ -1408,9 +1408,9 @@
///
/// ValueList ::= Value (',' Value)
///
-std::vector<const Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec,
+std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec,
RecTy *EltTy) {
- std::vector<const Init*> Result;
+ std::vector<Init*> Result;
RecTy *ItemType = EltTy;
unsigned int ArgN = 0;
if (ArgsRec != 0 && EltTy == 0) {
@@ -1421,7 +1421,7 @@
++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
@@ -1430,7 +1430,7 @@
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??");
@@ -1438,7 +1438,7 @@
++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;
@@ -1491,7 +1491,7 @@
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 "";
@@ -1575,7 +1575,7 @@
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)
@@ -1775,7 +1775,7 @@
}
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.
@@ -1949,7 +1949,7 @@
// 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();
Modified: llvm/trunk/utils/TableGen/TGParser.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/TGParser.h?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/TGParser.h (original)
+++ llvm/trunk/utils/TableGen/TGParser.h Fri Jul 29 17:43:06 2011
@@ -33,9 +33,9 @@
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,
+ 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 @@
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,18 +98,18 @@
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 llvm::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();
Modified: llvm/trunk/utils/TableGen/X86RecognizableInstr.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/X86RecognizableInstr.cpp?rev=136531&r1=136530&r2=136531&view=diff
==============================================================================
--- llvm/trunk/utils/TableGen/X86RecognizableInstr.cpp (original)
+++ llvm/trunk/utils/TableGen/X86RecognizableInstr.cpp Fri Jul 29 17:43:06 2011
@@ -162,7 +162,7 @@
/// @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 @@
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 @@
/// @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);
}
More information about the llvm-commits
mailing list