diff options
30 files changed, 879 insertions, 848 deletions
diff --git a/utils/TableGen/ARMDecoderEmitter.cpp b/utils/TableGen/ARMDecoderEmitter.cpp index c4bac10cfb..cc0c5da5cc 100644 --- a/utils/TableGen/ARMDecoderEmitter.cpp +++ b/utils/TableGen/ARMDecoderEmitter.cpp @@ -115,7 +115,7 @@ enum { /// byteFromBitsInit - Return the byte value from a BitsInit. /// Called from getByteField(). -static uint8_t byteFromBitsInit(BitsInit &init) { +static uint8_t byteFromBitsInit(const BitsInit &init) { int width = init.getNumBits(); assert(width <= 8 && "Field is too large for uint8_t!"); @@ -126,7 +126,7 @@ static uint8_t byteFromBitsInit(BitsInit &init) { uint8_t ret = 0; for (index = 0; index < width; index++) { - if (static_cast<BitInit*>(init.getBit(index))->getValue()) + if (static_cast<const BitInit*>(init.getBit(index))->getValue()) ret |= mask; mask <<= 1; @@ -136,12 +136,12 @@ static uint8_t byteFromBitsInit(BitsInit &init) { } static uint8_t getByteField(const Record &def, const char *str) { - BitsInit *bits = def.getValueAsBitsInit(str); + const BitsInit *bits = def.getValueAsBitsInit(str); return byteFromBitsInit(*bits); } -static BitsInit &getBitsField(const Record &def, const char *str) { - BitsInit *bits = def.getValueAsBitsInit(str); +static const BitsInit &getBitsField(const Record &def, const char *str) { + const BitsInit *bits = def.getValueAsBitsInit(str); return *bits; } @@ -184,15 +184,15 @@ static bool ValueNotSet(bit_value_t V) { static int Value(bit_value_t V) { return ValueNotSet(V) ? -1 : (V == BIT_FALSE ? 0 : 1); } -static bit_value_t bitFromBits(BitsInit &bits, unsigned index) { - if (BitInit *bit = dynamic_cast<BitInit*>(bits.getBit(index))) +static bit_value_t bitFromBits(const BitsInit &bits, unsigned index) { + if (const BitInit *bit = dynamic_cast<const 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, BitsInit &bits) { +static void dumpBits(raw_ostream &o, const BitsInit &bits) { unsigned index; for (index = bits.getNumBits(); index > 0; index--) { @@ -425,7 +425,7 @@ protected: if (AllInstructions[Opcode]->isPseudo) return; - BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef, "Inst"); + const BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef, "Inst"); for (unsigned i = 0; i < BIT_WIDTH; ++i) Insn[i] = bitFromBits(Bits, i); @@ -1559,7 +1559,7 @@ ARMDEBackend::populateInstruction(const CodeGenInstruction &CGI, const StringRef Name = Def.getName(); uint8_t Form = getByteField(Def, "Form"); - BitsInit &Bits = getBitsField(Def, "Inst"); + const 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 diff --git a/utils/TableGen/AsmMatcherEmitter.cpp b/utils/TableGen/AsmMatcherEmitter.cpp index d302941061..8afa76acf0 100644 --- a/utils/TableGen/AsmMatcherEmitter.cpp +++ b/utils/TableGen/AsmMatcherEmitter.cpp @@ -869,7 +869,7 @@ AsmMatcherInfo::getOperandClass(const CGIOperandList::OperandInfo &OI, int SubOpIdx) { Record *Rec = OI.Rec; if (SubOpIdx != -1) - Rec = dynamic_cast<DefInit*>(OI.MIOperandInfo->getArg(SubOpIdx))->getDef(); + Rec = dynamic_cast<const DefInit*>(OI.MIOperandInfo->getArg(SubOpIdx))->getDef(); if (Rec->isSubClassOf("RegisterOperand")) { // RegisterOperand may have an associated ParserMatchClass. If it does, @@ -879,7 +879,7 @@ AsmMatcherInfo::getOperandClass(const CGIOperandList::OperandInfo &OI, throw "Record `" + Rec->getName() + "' does not have a ParserMatchClass!\n"; - if (DefInit *DI= dynamic_cast<DefInit*>(R->getValue())) { + if (const DefInit *DI= dynamic_cast<const DefInit*>(R->getValue())) { Record *MatchClass = DI->getDef(); if (ClassInfo *CI = AsmOperandClasses[MatchClass]) return CI; @@ -1046,9 +1046,9 @@ void AsmMatcherInfo::BuildOperandClasses() { ClassInfo *CI = AsmOperandClasses[*it]; CI->Kind = ClassInfo::UserClass0 + Index; - ListInit *Supers = (*it)->getValueAsListInit("SuperClasses"); + const ListInit *Supers = (*it)->getValueAsListInit("SuperClasses"); for (unsigned i = 0, e = Supers->getSize(); i != e; ++i) { - DefInit *DI = dynamic_cast<DefInit*>(Supers->getElement(i)); + const DefInit *DI = dynamic_cast<const DefInit*>(Supers->getElement(i)); if (!DI) { PrintError((*it)->getLoc(), "Invalid super class reference!"); continue; @@ -1065,28 +1065,28 @@ void AsmMatcherInfo::BuildOperandClasses() { CI->ValueName = (*it)->getName(); // Get or construct the predicate method name. - Init *PMName = (*it)->getValueInit("PredicateMethod"); - if (StringInit *SI = dynamic_cast<StringInit*>(PMName)) { + const Init *PMName = (*it)->getValueInit("PredicateMethod"); + if (const StringInit *SI = dynamic_cast<const StringInit*>(PMName)) { CI->PredicateMethod = SI->getValue(); } else { - assert(dynamic_cast<UnsetInit*>(PMName) && + assert(dynamic_cast<const UnsetInit*>(PMName) && "Unexpected PredicateMethod field!"); CI->PredicateMethod = "is" + CI->ClassName; } // Get or construct the render method name. - Init *RMName = (*it)->getValueInit("RenderMethod"); - if (StringInit *SI = dynamic_cast<StringInit*>(RMName)) { + const Init *RMName = (*it)->getValueInit("RenderMethod"); + if (const StringInit *SI = dynamic_cast<const StringInit*>(RMName)) { CI->RenderMethod = SI->getValue(); } else { - assert(dynamic_cast<UnsetInit*>(RMName) && + assert(dynamic_cast<const UnsetInit*>(RMName) && "Unexpected RenderMethod field!"); CI->RenderMethod = "add" + CI->ClassName + "Operands"; } // Get the parse method name or leave it as empty. - Init *PRMName = (*it)->getValueInit("ParserMethod"); - if (StringInit *SI = dynamic_cast<StringInit*>(PRMName)) + const Init *PRMName = (*it)->getValueInit("ParserMethod"); + if (const StringInit *SI = dynamic_cast<const StringInit*>(PRMName)) CI->ParserMethod = SI->getValue(); AsmOperandClasses[*it] = CI; diff --git a/utils/TableGen/CallingConvEmitter.cpp b/utils/TableGen/CallingConvEmitter.cpp index c51afd82a3..37758bc1cf 100644 --- a/utils/TableGen/CallingConvEmitter.cpp +++ b/utils/TableGen/CallingConvEmitter.cpp @@ -40,7 +40,7 @@ void CallingConvEmitter::run(raw_ostream &O) { void CallingConvEmitter::EmitCallingConv(Record *CC, raw_ostream &O) { - ListInit *CCActions = CC->getValueAsListInit("Actions"); + const ListInit *CCActions = CC->getValueAsListInit("Actions"); Counter = 0; O << "\n\nstatic bool " << CC->getName() @@ -67,7 +67,7 @@ void CallingConvEmitter::EmitAction(Record *Action, O << IndentStr << "if ("; if (Action->isSubClassOf("CCIfType")) { - ListInit *VTs = Action->getValueAsListInit("VTs"); + const ListInit *VTs = Action->getValueAsListInit("VTs"); for (unsigned i = 0, e = VTs->getSize(); i != e; ++i) { Record *VT = VTs->getElementAsRecord(i); if (i != 0) O << " ||\n " << IndentStr; @@ -91,7 +91,7 @@ void CallingConvEmitter::EmitAction(Record *Action, << "(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))\n" << IndentStr << " return false;\n"; } else if (Action->isSubClassOf("CCAssignToReg")) { - ListInit *RegList = Action->getValueAsListInit("RegList"); + const ListInit *RegList = Action->getValueAsListInit("RegList"); if (RegList->getSize() == 1) { O << IndentStr << "if (unsigned Reg = State.AllocateReg("; O << getQualifiedName(RegList->getElementAsRecord(0)) << ")) {\n"; @@ -112,8 +112,8 @@ void CallingConvEmitter::EmitAction(Record *Action, O << IndentStr << " return false;\n"; O << IndentStr << "}\n"; } else if (Action->isSubClassOf("CCAssignToRegWithShadow")) { - ListInit *RegList = Action->getValueAsListInit("RegList"); - ListInit *ShadowRegList = Action->getValueAsListInit("ShadowRegList"); + const ListInit *RegList = Action->getValueAsListInit("RegList"); + const ListInit *ShadowRegList = Action->getValueAsListInit("ShadowRegList"); if (ShadowRegList->getSize() >0 && ShadowRegList->getSize() != RegList->getSize()) throw "Invalid length of list of shadowed registers"; diff --git a/utils/TableGen/ClangAttrEmitter.cpp b/utils/TableGen/ClangAttrEmitter.cpp index 40bbb08524..ab74598e6d 100644 --- a/utils/TableGen/ClangAttrEmitter.cpp +++ b/utils/TableGen/ClangAttrEmitter.cpp @@ -21,7 +21,7 @@ using namespace llvm; static const std::vector<StringRef> getValueAsListOfStrings(Record &R, StringRef FieldName) { - ListInit *List = R.getValueAsListInit(FieldName); + const ListInit *List = R.getValueAsListInit(FieldName); assert (List && "Got a null ListInit"); std::vector<StringRef> Strings; @@ -31,9 +31,9 @@ getValueAsListOfStrings(Record &R, StringRef FieldName) { i != e; ++i) { assert(*i && "Got a null element in a ListInit"); - if (StringInit *S = dynamic_cast<StringInit *>(*i)) + if (const StringInit *S = dynamic_cast<const StringInit *>(*i)) Strings.push_back(S->getValue()); - else if (CodeInit *C = dynamic_cast<CodeInit *>(*i)) + else if (const CodeInit *C = dynamic_cast<const CodeInit *>(*i)) Strings.push_back(C->getValue()); else assert(false && "Got a non-string, non-code element in a ListInit"); diff --git a/utils/TableGen/ClangDiagnosticsEmitter.cpp b/utils/TableGen/ClangDiagnosticsEmitter.cpp index 0a48e75681..2ef1e8ba34 100644 --- a/utils/TableGen/ClangDiagnosticsEmitter.cpp +++ b/utils/TableGen/ClangDiagnosticsEmitter.cpp @@ -74,7 +74,7 @@ getCategoryFromDiagGroup(const Record *Group, static std::string getDiagnosticCategory(const Record *R, DiagGroupParentMap &DiagGroupParents) { // If the diagnostic is in a group, and that group has a category, use it. - if (DefInit *Group = dynamic_cast<DefInit*>(R->getValueInit("Group"))) { + if (const DefInit *Group = dynamic_cast<const DefInit*>(R->getValueInit("Group"))) { // Check the diagnostic's diag group for a category. std::string CatName = getCategoryFromDiagGroup(Group->getDef(), DiagGroupParents); @@ -159,7 +159,7 @@ void ClangDiagsDefsEmitter::run(raw_ostream &OS) { OS.write_escaped(R.getValueAsString("Text")) << '"'; // Warning associated with the diagnostic. - if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group"))) { + if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Group"))) { OS << ", \""; OS.write_escaped(DI->getDef()->getValueAsString("GroupName")) << '"'; } else { @@ -225,7 +225,7 @@ void ClangDiagGroupsEmitter::run(raw_ostream &OS) { Records.getAllDerivedDefinitions("Diagnostic"); for (unsigned i = 0, e = Diags.size(); i != e; ++i) { const Record *R = Diags[i]; - DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("Group")); + const DefInit *DI = dynamic_cast<const DefInit*>(R->getValueInit("Group")); if (DI == 0) continue; std::string GroupName = DI->getDef()->getValueAsString("GroupName"); DiagsInGroup[GroupName].DiagsInGroup.push_back(R); diff --git a/utils/TableGen/ClangSACheckersEmitter.cpp b/utils/TableGen/ClangSACheckersEmitter.cpp index 97739c6b3f..d509173cef 100644 --- a/utils/TableGen/ClangSACheckersEmitter.cpp +++ b/utils/TableGen/ClangSACheckersEmitter.cpp @@ -28,7 +28,7 @@ static bool isHidden(const Record &R) { if (R.getValueAsBit("Hidden")) return true; // Not declared as hidden, check the parent package if it is hidden. - if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("ParentPackage"))) + if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("ParentPackage"))) return isHidden(*DI->getDef()); return false; @@ -42,7 +42,7 @@ static std::string getPackageFullName(const Record *R); static std::string getParentPackageFullName(const Record *R) { std::string name; - if (DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("ParentPackage"))) + if (const DefInit *DI = dynamic_cast<const DefInit*>(R->getValueInit("ParentPackage"))) name = getPackageFullName(DI->getDef()); return name; } @@ -63,8 +63,8 @@ static std::string getCheckerFullName(const Record *R) { } static std::string getStringValue(const Record &R, StringRef field) { - if (StringInit * - SI = dynamic_cast<StringInit*>(R.getValueInit(field))) + if (const StringInit * + SI = dynamic_cast<const StringInit*>(R.getValueInit(field))) return SI->getValue(); return std::string(); } @@ -129,8 +129,8 @@ void ClangSACheckersEmitter::run(raw_ostream &OS) { for (unsigned i = 0, e = checkers.size(); i != e; ++i) { Record *R = checkers[i]; Record *package = 0; - if (DefInit * - DI = dynamic_cast<DefInit*>(R->getValueInit("ParentPackage"))) + if (const DefInit * + DI = dynamic_cast<const 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 @@ void ClangSACheckersEmitter::run(raw_ostream &OS) { Record *currR = isCheckerNamed(R) ? R : package; // Insert the checker and its parent packages into the subgroups set of // the corresponding parent package. - while (DefInit *DI - = dynamic_cast<DefInit*>(currR->getValueInit("ParentPackage"))) { + while (const DefInit *DI + = dynamic_cast<const 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 (DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("Group"))) + if (const DefInit *DI = dynamic_cast<const 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 (DefInit *DI = dynamic_cast<DefInit*>(packages[i]->getValueInit("Group"))) + if (const DefInit *DI = dynamic_cast<const DefInit*>(packages[i]->getValueInit("Group"))) addPackageToCheckerGroup(packages[i], DI->getDef(), recordGroupMap); typedef std::map<std::string, const Record *> SortedRecords; @@ -204,7 +204,7 @@ void ClangSACheckersEmitter::run(raw_ostream &OS) { OS << "PACKAGE(" << "\""; OS.write_escaped(getPackageFullName(&R)) << "\", "; // Group index - if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group"))) + if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Group"))) OS << groupToSortIndex[DI->getDef()] << ", "; else OS << "-1, "; @@ -232,7 +232,7 @@ void ClangSACheckersEmitter::run(raw_ostream &OS) { OS << "\""; OS.write_escaped(getStringValue(R, "HelpText")) << "\", "; // Group index - if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group"))) + if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Group"))) OS << groupToSortIndex[DI->getDef()] << ", "; else OS << "-1, "; diff --git a/utils/TableGen/CodeEmitterGen.cpp b/utils/TableGen/CodeEmitterGen.cpp index 8b5cddae25..c11e4d0beb 100644 --- a/utils/TableGen/CodeEmitterGen.cpp +++ b/utils/TableGen/CodeEmitterGen.cpp @@ -38,16 +38,16 @@ void CodeEmitterGen::reverseBits(std::vector<Record*> &Insts) { R->getValueAsBit("isPseudo")) continue; - BitsInit *BI = R->getValueAsBitsInit("Inst"); + const BitsInit *BI = R->getValueAsBitsInit("Inst"); unsigned numBits = BI->getNumBits(); - SmallVector<Init *, 16> NewBits(numBits); + SmallVector<const Init *, 16> NewBits(numBits); for (unsigned bit = 0, end = numBits / 2; bit != end; ++bit) { unsigned bitSwapIdx = numBits - bit - 1; - Init *OrigBit = BI->getBit(bit); - Init *BitSwap = BI->getBit(bitSwapIdx); + const Init *OrigBit = BI->getBit(bit); + const Init *BitSwap = BI->getBit(bitSwapIdx); NewBits[bit] = BitSwap; NewBits[bitSwapIdx] = OrigBit; } @@ -56,7 +56,7 @@ void CodeEmitterGen::reverseBits(std::vector<Record*> &Insts) { NewBits[middle] = BI->getBit(middle); } - BitsInit *NewBI = new BitsInit(ArrayRef<Init *>(NewBits)); + BitsInit *NewBI = new BitsInit(ArrayRef<const Init *>(NewBits)); // Update the bits in reversed order so that emitInstrOpBits will get the // correct endianness. @@ -67,12 +67,12 @@ void CodeEmitterGen::reverseBits(std::vector<Record*> &Insts) { // If the VarBitInit at position 'bit' matches the specified variable then // return the variable bit position. Otherwise return -1. int CodeEmitterGen::getVariableBit(const std::string &VarName, - BitsInit *BI, int bit) { - if (VarBitInit *VBI = dynamic_cast<VarBitInit*>(BI->getBit(bit))) { - if (VarInit *VI = dynamic_cast<VarInit*>(VBI->getVariable())) + 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())) if (VI->getName() == VarName) return VBI->getBitNum(); - } else if (VarInit *VI = dynamic_cast<VarInit*>(BI->getBit(bit))) { + } else if (const VarInit *VI = dynamic_cast<const VarInit*>(BI->getBit(bit))) { if (VI->getName() == VarName) return 0; } @@ -81,7 +81,7 @@ int CodeEmitterGen::getVariableBit(const std::string &VarName, } void CodeEmitterGen:: -AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName, +AddCodeToMergeInOperand(Record *R, const BitsInit *BI, const std::string &VarName, unsigned &NumberedOp, std::string &Case, CodeGenTarget &Target) { CodeGenInstruction &CGI = Target.getInstruction(R); @@ -185,7 +185,7 @@ std::string CodeEmitterGen::getInstructionCase(Record *R, CodeGenTarget &Target) { std::string Case; - BitsInit *BI = R->getValueAsBitsInit("Inst"); + const BitsInit *BI = R->getValueAsBitsInit("Inst"); const std::vector<RecordVal> &Vals = R->getValues(); unsigned NumberedOp = 0; @@ -242,12 +242,12 @@ void CodeEmitterGen::run(raw_ostream &o) { continue; } - BitsInit *BI = R->getValueAsBitsInit("Inst"); + const 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 (BitInit *B = dynamic_cast<BitInit*>(BI->getBit(e-i-1))) + if (const BitInit *B = dynamic_cast<const BitInit*>(BI->getBit(e-i-1))) Value |= B->getValue() << (e-i-1); } o << " " << Value << "U," << '\t' << "// " << R->getName() << "\n"; diff --git a/utils/TableGen/CodeEmitterGen.h b/utils/TableGen/CodeEmitterGen.h index a874d970fe..1f841c37a3 100644 --- a/utils/TableGen/CodeEmitterGen.h +++ b/utils/TableGen/CodeEmitterGen.h @@ -35,10 +35,10 @@ private: void emitMachineOpEmitter(raw_ostream &o, const std::string &Namespace); void emitGetValueBit(raw_ostream &o, const std::string &Namespace); void reverseBits(std::vector<Record*> &Insts); - int getVariableBit(const std::string &VarName, BitsInit *BI, int bit); + int getVariableBit(const std::string &VarName, const BitsInit *BI, int bit); std::string getInstructionCase(Record *R, CodeGenTarget &Target); void - AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName, + AddCodeToMergeInOperand(Record *R, const BitsInit *BI, const std::string &VarName, unsigned &NumberedOp, std::string &Case, CodeGenTarget &Target); diff --git a/utils/TableGen/CodeGenDAGPatterns.cpp b/utils/TableGen/CodeGenDAGPatterns.cpp index 16585f7a91..2a75849d67 100644 --- a/utils/TableGen/CodeGenDAGPatterns.cpp +++ b/utils/TableGen/CodeGenDAGPatterns.cpp @@ -583,7 +583,7 @@ typedef DepVarMap::const_iterator DepVarMap_citer; static void FindDepVarsOf(TreePatternNode *N, DepVarMap &DepMap) { if (N->isLeaf()) { - if (dynamic_cast<DefInit*>(N->getLeafValue()) != NULL) + if (dynamic_cast<const DefInit*>(N->getLeafValue()) != NULL) DepMap[N->getName()]++; } else { for (size_t i = 0, e = N->getNumChildren(); i != e; ++i) @@ -692,7 +692,7 @@ static unsigned getPatternSize(const TreePatternNode *P, unsigned Size = 3; // The node itself. // If the root node is a ConstantSDNode, increases its size. // e.g. (set R32:$dst, 0). - if (P->isLeaf() && dynamic_cast<IntInit*>(P->getLeafValue())) + if (P->isLeaf() && dynamic_cast<const IntInit*>(P->getLeafValue())) Size += 2; // FIXME: This is a hack to statically increase the priority of patterns @@ -716,7 +716,7 @@ static unsigned getPatternSize(const TreePatternNode *P, Child->getType(0) != MVT::Other) Size += getPatternSize(Child, CGP); else if (Child->isLeaf()) { - if (dynamic_cast<IntInit*>(Child->getLeafValue())) + if (dynamic_cast<const 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 @@ getPatternComplexity(const CodeGenDAGPatterns &CGP) const { std::string PatternToMatch::getPredicateCheck() const { std::string PredicateCheck; for (unsigned i = 0, e = Predicates->getSize(); i != e; ++i) { - if (DefInit *Pred = dynamic_cast<DefInit*>(Predicates->getElement(i))) { + if (const DefInit *Pred = dynamic_cast<const DefInit*>(Predicates->getElement(i))) { Record *Def = Pred->getDef(); if (!Def->isSubClassOf("Predicate")) { #ifndef NDEBUG @@ -866,12 +866,12 @@ bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N, // The NodeToApply must be a leaf node that is a VT. OtherOperandNum must // have an integer type that is smaller than the VT. if (!NodeToApply->isLeaf() || - !dynamic_cast<DefInit*>(NodeToApply->getLeafValue()) || - !static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef() + !dynamic_cast<const DefInit*>(NodeToApply->getLeafValue()) || + !static_cast<const DefInit*>(NodeToApply->getLeafValue())->getDef() ->isSubClassOf("ValueType")) TP.error(N->getOperator()->getName() + " expects a VT operand!"); MVT::SimpleValueType VT = - getValueType(static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef()); + getValueType(static_cast<const DefInit*>(NodeToApply->getLeafValue())->getDef()); EEVT::TypeSet TypeListTmp(VT, TP); @@ -1021,10 +1021,10 @@ static unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) { return PFRec->getOnlyTree()->getNumTypes(); // Get the result tree. - DagInit *Tree = Operator->getValueAsDag("Fragment"); + const DagInit *Tree = Operator->getValueAsDag("Fragment"); Record *Op = 0; - if (Tree && dynamic_cast<DefInit*>(Tree->getOperator())) - Op = dynamic_cast<DefInit*>(Tree->getOperator())->getDef(); + if (Tree && dynamic_cast<const DefInit*>(Tree->getOperator())) + Op = dynamic_cast<const DefInit*>(Tree->getOperator())->getDef(); assert(Op && "Invalid Fragment"); return GetNumNodeResults(Op, CDP); } @@ -1098,8 +1098,8 @@ bool TreePatternNode::isIsomorphicTo(const TreePatternNode *N, return false; if (isLeaf()) { - if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) { - if (DefInit *NDI = dynamic_cast<DefInit*>(N->getLeafValue())) { + if (const DefInit *DI = dynamic_cast<const DefInit*>(getLeafValue())) { + if (const DefInit *NDI = dynamic_cast<const DefInit*>(N->getLeafValue())) { return ((DI->getDef() == NDI->getDef()) && (DepVars.find(getName()) == DepVars.end() || getName() == N->getName())); @@ -1155,9 +1155,9 @@ SubstituteFormalArguments(std::map<std::string, TreePatternNode*> &ArgMap) { for (unsigned i = 0, e = getNumChildren(); i != e; ++i) { TreePatternNode *Child = getChild(i); if (Child->isLeaf()) { - Init *Val = Child->getLeafValue(); - if (dynamic_cast<DefInit*>(Val) && - static_cast<DefInit*>(Val)->getDef()->getName() == "node") { + const Init *Val = Child->getLeafValue(); + if (dynamic_cast<const DefInit*>(Val) && + static_cast<const 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 @@ getIntrinsicInfo(const CodeGenDAGPatterns &CDP) const { return 0; unsigned IID = - dynamic_cast<IntInit*>(getChild(0)->getLeafValue())->getValue(); + dynamic_cast<const IntInit*>(getChild(0)->getLeafValue())->getValue(); return &CDP.getIntrinsicInfo(IID); } @@ -1329,7 +1329,7 @@ const ComplexPattern * TreePatternNode::getComplexPatternInfo(const CodeGenDAGPatterns &CGP) const { if (!isLeaf()) return 0; - DefInit *DI = dynamic_cast<DefInit*>(getLeafValue()); + const DefInit *DI = dynamic_cast<const DefInit*>(getLeafValue()); if (DI && DI->getDef()->isSubClassOf("ComplexPattern")) return &CGP.getComplexPattern(DI->getDef()); return 0; @@ -1382,7 +1382,7 @@ TreePatternNode::isCommutativeIntrinsic(const CodeGenDAGPatterns &CDP) const { bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) { CodeGenDAGPatterns &CDP = TP.getDAGPatterns(); if (isLeaf()) { - if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) { + if (const DefInit *DI = dynamic_cast<const 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 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) { return MadeChange; } - if (IntInit *II = dynamic_cast<IntInit*>(getLeafValue())) { + if (const IntInit *II = dynamic_cast<const IntInit*>(getLeafValue())) { assert(Types.size() == 1 && "Invalid IntInit"); // Int inits are always integers. :) @@ -1651,7 +1651,7 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) { static bool OnlyOnRHSOfCommutative(TreePatternNode *N) { if (!N->isLeaf() && N->getOperator()->getName() == "imm") return true; - if (N->isLeaf() && dynamic_cast<IntInit*>(N->getLeafValue())) + if (N->isLeaf() && dynamic_cast<const IntInit*>(N->getLeafValue())) return true; return false; } @@ -1701,14 +1701,14 @@ bool TreePatternNode::canPatternMatch(std::string &Reason, // TreePattern implementation // -TreePattern::TreePattern(Record *TheRec, ListInit *RawPat, bool isInput, +TreePattern::TreePattern(Record *TheRec, const 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, DagInit *Pat, bool isInput, +TreePattern::TreePattern(Record *TheRec, const DagInit *Pat, bool isInput, CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){ isInputPattern = isInput; Trees.push_back(ParseTreePattern(Pat, "")); @@ -1739,8 +1739,8 @@ void TreePattern::ComputeNamedNodes(TreePatternNode *N) { } -TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){ - if (DefInit *DI = dynamic_cast<DefInit*>(TheInit)) { +TreePatternNode *TreePattern::ParseTreePattern(const Init *TheInit, StringRef OpName){ + if (const DefInit *DI = dynamic_cast<const DefInit*>(TheInit)) { Record *R = DI->getDef(); // Direct reference to a leaf DagNode or PatFrag? Turn it into a @@ -1748,7 +1748,7 @@ TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){ /// (foo GPR, imm) -> (foo GPR, (imm)) if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag")) return ParseTreePattern(new DagInit(DI, "", - std::vector<std::pair<Init*, std::string> >()), + std::vector<std::pair<const Init*, std::string> >()), OpName); // Input argument? @@ -1763,26 +1763,26 @@ TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){ return Res; } - if (IntInit *II = dynamic_cast<IntInit*>(TheInit)) { + if (const IntInit *II = dynamic_cast<const IntInit*>(TheInit)) { if (!OpName.empty()) error("Constant int argument should not have a name!"); return new TreePatternNode(II, 1); } - if (BitsInit *BI = dynamic_cast<BitsInit*>(TheInit)) { + if (const BitsInit *BI = dynamic_cast<const BitsInit*>(TheInit)) { // Turn this into an IntInit. - Init *II = BI->convertInitializerTo(IntRecTy::get()); - if (II == 0 || !dynamic_cast<IntInit*>(II)) + const Init *II = BI->convertInitializerTo(IntRecTy::get()); + if (II == 0 || !dynamic_cast<const IntInit*>(II)) error("Bits value must be constants!"); return ParseTreePattern(II, OpName); } - DagInit *Dag = dynamic_cast<DagInit*>(TheInit); + const DagInit *Dag = dynamic_cast<const DagInit*>(TheInit); if (!Dag) { TheInit->dump(); error("Pattern has unexpected init kind!"); } - DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator()); + const DefInit *OpDef = dynamic_cast<const DefInit*>(Dag->getOperator()); if (!OpDef) error("Pattern has unexpected operator type!"); Record *Operator = OpDef->getDef(); @@ -1947,7 +1947,7 @@ InferAllTypes(const StringMap<SmallVector<TreePatternNode*,1> > *InNamedTypes) { // us to match things like: // def : Pat<(v1i64 (bitconvert(v2i32 DPR:$src))), (v1i64 DPR:$src)>; if (Nodes[i] == Trees[0] && Nodes[i]->isLeaf()) { - DefInit *DI = dynamic_cast<DefInit*>(Nodes[i]->getLeafValue()); + const DefInit *DI = dynamic_cast<const DefInit*>(Nodes[i]->getLeafValue()); if (DI && (DI->getDef()->isSubClassOf("RegisterClass") || DI->getDef()->isSubClassOf("RegisterOperand"))) continue; @@ -2096,7 +2096,7 @@ void CodeGenDAGPatterns::ParsePatternFragments() { // First step, parse all of the fragments. for (unsigned i = 0, e = Fragments.size(); i != e; ++i) { - DagInit *Tree = Fragments[i]->getValueAsDag("Fragment"); + const DagInit *Tree = Fragments[i]->getValueAsDag("Fragment"); TreePattern *P = new TreePattern(Fragments[i], Tree, true, *this); PatternFragments[Fragments[i]] = P; @@ -2108,8 +2108,8 @@ void CodeGenDAGPatterns::ParsePatternFragments() { P->error("Cannot have unnamed 'node' values in pattern fragment!"); // Parse the operands list. - DagInit *OpsList = Fragments[i]->getValueAsDag("Operands"); - DefInit *OpsOp = dynamic_cast<DefInit*>(OpsList->getOperator()); + const DagInit *OpsList = Fragments[i]->getValueAsDag("Operands"); + const DefInit *OpsOp = dynamic_cast<const DefInit*>(OpsList->getOperator()); // Special cases: ops == outs == ins. Different names are used to // improve readability. if (!OpsOp || @@ -2121,8 +2121,8 @@ void CodeGenDAGPatterns::ParsePatternFragments() { // Copy over the arguments. Args.clear(); for (unsigned j = 0, e = OpsList->getNumArgs(); j != e; ++j) { - if (!dynamic_cast<DefInit*>(OpsList->getArg(j)) || - static_cast<DefInit*>(OpsList->getArg(j))-> + if (!dynamic_cast<const DefInit*>(OpsList->getArg(j)) || + static_cast<const DefInit*>(OpsList->getArg(j))-> getDef()->getName() != "node") P->error("Operands list should all be 'node' values."); if (OpsList->getArgName(j).empty()) @@ -2180,19 +2180,19 @@ void CodeGenDAGPatterns::ParseDefaultOperands() { // Find some SDNode. assert(!SDNodes.empty() && "No SDNodes parsed?"); - Init *SomeSDNode = DefInit::get(SDNodes.begin()->first); + const 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) { - DagInit *DefaultInfo = DefaultOps[iter][i]->getValueAsDag("DefaultOps"); + const 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<Init*, std::string> > Ops; + std::vector<std::pair<const 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))); - DagInit *DI = new DagInit(SomeSDNode, "", Ops); + const DagInit *DI = new DagInit(SomeSDNode, "", Ops); // Create a TreePattern to parse this. TreePattern P(DefaultOps[iter][i], DI, false, *this); @@ -2231,7 +2231,7 @@ static bool HandleUse(TreePattern *I, TreePatternNode *Pat, // No name -> not interesting. if (Pat->getName().empty()) { if (Pat->isLeaf()) { - DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue()); + const DefInit *DI = dynamic_cast<const DefInit*>(Pat->getLeafValue()); if (DI && (DI->getDef()->isSubClassOf("RegisterClass") || DI->getDef()->isSubClassOf("RegisterOperand"))) I->error("Input " + DI->getDef()->getName() + " must be named!"); @@ -2241,7 +2241,7 @@ static bool HandleUse(TreePattern *I, TreePatternNode *Pat, Record *Rec; if (Pat->isLeaf()) { - DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue()); + const DefInit *DI = dynamic_cast<const DefInit*>(Pat->getLeafValue()); if (!DI) I->error("Input $" + Pat->getName() + " must be an identifier!"); Rec = DI->getDef(); } else { @@ -2259,7 +2259,7 @@ static bool HandleUse(TreePattern *I, TreePatternNode *Pat, } Record *SlotRec; if (Slot->isLeaf()) { - SlotRec = dynamic_cast<DefInit*>(Slot->getLeafValue())->getDef(); + SlotRec = dynamic_cast<const DefInit*>(Slot->getLeafValue())->getDef(); } else { assert(Slot->getNumChildren() == 0 && "can't be a use with children!"); SlotRec = Slot->getOperator(); @@ -2294,7 +2294,7 @@ FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat, if (!Dest->isLeaf()) I->error("implicitly defined value should be a register!"); - DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue()); + const DefInit *Val = dynamic_cast<const DefInit*>(Dest->getLeafValue()); if (!Val || !Val->getDef()->isSubClassOf("Register")) I->error("implicitly defined value should be a register!"); InstImpResults.push_back(Val->getDef()); @@ -2335,7 +2335,7 @@ FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat, if (!Dest->isLeaf()) I->error("set destination should be a register!"); - DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue()); + const DefInit *Val = dynamic_cast<const DefInit*>(Dest->getLeafValue()); if (!Val) I->error("set destination should be a register!"); @@ -2401,7 +2401,7 @@ private: return false; const TreePatternNode *N0 = N->getChild(0); - if (!N0->isLeaf() || !dynamic_cast<DefInit*>(N0->getLeafValue())) + if (!N0->isLeaf() || !dynamic_cast<const DefInit*>(N0->getLeafValue())) return false; const TreePatternNode *N1 = N->getChild(1); @@ -2418,7 +2418,7 @@ private: void AnalyzeNode(const TreePatternNode *N) { if (N->isLeaf()) { - if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) { + if (const DefInit *DI = dynamic_cast<const DefInit*>(N->getLeafValue())) { Record *LeafRec = DI->getDef(); // Handle ComplexPattern leaves. if (LeafRec->isSubClassOf("ComplexPattern")) { @@ -2525,9 +2525,9 @@ void CodeGenDAGPatterns::ParseInstructions() { std::vector<Record*> Instrs = Records.getAllDerivedDefinitions("Instruction"); for (unsigned i = 0, e = Instrs.size(); i != e; ++i) { - ListInit *LI = 0; + const ListInit *LI = 0; - if (dynamic_cast<ListInit*>(Instrs[i]->getValueInit("Pattern"))) + if (dynamic_cast<const ListInit*>(Instrs[i]->getValueInit("Pattern"))) LI = Instrs[i]->getValueAsListInit("Pattern"); // If there is no pattern, only collect minimal information about the @@ -2619,7 +2619,7 @@ void CodeGenDAGPatterns::ParseInstructions() { if (i == 0) Res0Node = RNode; - Record *R = dynamic_cast<DefInit*>(RNode->getLeafValue())->getDef(); + Record *R = dynamic_cast<const 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!"); @@ -2664,8 +2664,8 @@ void CodeGenDAGPatterns::ParseInstructions() { InstInputsCheck.erase(OpName); // It occurred, remove from map. if (InVal->isLeaf() && - dynamic_cast<DefInit*>(InVal->getLeafValue())) { - Record *InRec = static_cast<DefInit*>(InVal->getLeafValue())->getDef(); + dynamic_cast<const DefInit*>(InVal->getLeafValue())) { + Record *InRec = static_cast<const DefInit*>(InVal->getLeafValue())->getDef(); if (Op.Rec != InRec && !InRec->isSubClassOf("ComplexPattern")) I->error("Operand $" + OpName + "'s register class disagrees" " between the operand and pattern"); @@ -2865,13 +2865,13 @@ void CodeGenDAGPatterns::ParsePatterns() { for (unsigned i = 0, e = Patterns.size(); i != e; ++i) { Record *CurPattern = Patterns[i]; - DagInit *Tree = CurPattern->getValueAsDag("PatternToMatch"); + const DagInit *Tree = CurPattern->getValueAsDag("PatternToMatch"); TreePattern *Pattern = new TreePattern(CurPattern, Tree, true, *this); // Inline pattern fragments into it. Pattern->InlinePatternFragments(); - ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs"); + const ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs"); if (LI->getSize() == 0) continue; // no pattern. // Parse the instruction. @@ -3183,7 +3183,7 @@ static void GenerateVariantsOf(TreePatternNode *N, for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) { TreePatternNode *Child = N->getChild(i); if (Child->isLeaf()) - if (DefInit *DI = dynamic_cast<DefInit*>(Child->getLeafValue())) { + if (const DefInit *DI = dynamic_cast<const DefInit*>(Child->getLeafValue())) { Record *RR = DI->getDef(); if (RR->isSubClassOf("Register")) continue; diff --git a/utils/TableGen/CodeGenDAGPatterns.h b/utils/TableGen/CodeGenDAGPatterns.h index 936fd01464..833eef0653 100644 --- a/utils/TableGen/CodeGenDAGPatterns.h +++ b/utils/TableGen/CodeGenDAGPatterns.h @@ -306,7 +306,7 @@ class TreePatternNode { /// Val - The init value (e.g. the "GPRC" record, or "7") for a leaf. /// - Init *Val; + const Init *Val; /// Name - The name given to this node with the :$foo notation. /// @@ -327,7 +327,7 @@ public: : Operator(Op), Val(0), TransformFn(0), Children(Ch) { Types.resize(NumResults); } - TreePatternNode(Init *val, unsigned NumResults) // leaf ctor + TreePatternNode(const Init *val, unsigned NumResults) // leaf ctor : Operator(0), Val(val), TransformFn(0) { Types.resize(NumResults); } @@ -358,7 +358,7 @@ public: return Types[ResNo].isDynamicallyResolved(); } - Init *getLeafValue() const { assert(isLeaf()); return Val; } + const Init *getLeafValue() const { assert(isLeaf()); return Val; } Record *getOperator() const { assert(!isLeaf()); return Operator; } unsigned getNumChildren() const { return Children.size(); } @@ -517,9 +517,9 @@ public: /// TreePattern constructor - Parse the specified DagInits into the /// current record. - TreePattern(Record *TheRec, ListInit *RawPat, bool isInput, + TreePattern(Record *TheRec, const ListInit *RawPat, bool isInput, CodeGenDAGPatterns &ise); - TreePattern(Record *TheRec, DagInit *Pat, bool isInput, + TreePattern(Record *TheRec, const DagInit *Pat, bool isInput, CodeGenDAGPatterns &ise); TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput, CodeGenDAGPatterns &ise); @@ -576,7 +576,7 @@ public: void dump() const; private: - TreePatternNode *ParseTreePattern(Init *DI, StringRef OpName); + TreePatternNode *ParseTreePattern(const Init *DI, StringRef OpName); void ComputeNamedNodes(); void ComputeNamedNodes(TreePatternNode *N); }; @@ -631,7 +631,7 @@ public: /// processed to produce isel. class PatternToMatch { public: - PatternToMatch(Record *srcrecord, ListInit *preds, + PatternToMatch(Record *srcrecord, const ListInit *preds, TreePatternNode *src, TreePatternNode *dst, const std::vector<Record*> &dstregs, unsigned complexity, unsigned uid) @@ -639,7 +639,7 @@ public: Dstregs(dstregs), AddedComplexity(complexity), ID(uid) {} Record *SrcRecord; // Originating Record for the pattern. - ListInit *Predicates; // Top level predicate conditions to match. + const ListInit *Predicates; // Top level predicate conditions to match. TreePatternNode *SrcPattern; // Source pattern to match. TreePatternNode *DstPattern; // Resulting pattern. std::vector<Record*> Dstregs; // Physical register defs being matched. @@ -647,7 +647,7 @@ public: unsigned ID; // Unique ID for the record. Record *getSrcRecord() const { return SrcRecord; } - ListInit *getPredicates() const { return Predicates; } + const ListInit *getPredicates() const { return Predicates; } TreePatternNode *getSrcPattern() const { return SrcPattern; } TreePatternNode *getDstPattern() const { return DstPattern; } const std::vector<Record*> &getDstRegs() const { return Dstregs; } diff --git a/utils/TableGen/CodeGenInstruction.cpp b/utils/TableGen/CodeGenInstruction.cpp index 86a377b7a8..fdeb5073ec 100644 --- a/utils/TableGen/CodeGenInstruction.cpp +++ b/utils/TableGen/CodeGenInstruction.cpp @@ -30,9 +30,9 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) { hasOptionalDef = false; isVariadic = false; - DagInit *OutDI = R->getValueAsDag("OutOperandList"); + const DagInit *OutDI = R->getValueAsDag("OutOperandList"); - if (DefInit *Init = dynamic_cast<DefInit*>(OutDI->getOperator())) { + if (const DefInit *Init = dynamic_cast<const DefInit*>(OutDI->getOperator())) { if (Init->getDef()->getName() != "outs") throw R->getName() + ": invalid def name for output list: use 'outs'"; } else @@ -40,8 +40,8 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) { NumDefs = OutDI->getNumArgs(); - DagInit *InDI = R->getValueAsDag("InOperandList"); - if (DefInit *Init = dynamic_cast<DefInit*>(InDI->getOperator())) { + const DagInit *InDI = R->getValueAsDag("InOperandList"); + if (const DefInit *Init = dynamic_cast<const DefInit*>(InDI->getOperator())) { if (Init->getDef()->getName() != "ins") throw R->getName() + ": invalid def name for input list: use 'ins'"; } else @@ -50,7 +50,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) { unsigned MIOperandNo = 0; std::set<std::string> OperandNames; for (unsigned i = 0, e = InDI->getNumArgs()+OutDI->getNumArgs(); i != e; ++i){ - Init *ArgInit; + const Init *ArgInit; std::string ArgName; if (i < NumDefs) { ArgInit = OutDI->getArg(i); @@ -60,7 +60,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) { ArgName = InDI->getArgName(i-NumDefs); } - DefInit *Arg = dynamic_cast<DefInit*>(ArgInit); + const DefInit *Arg = dynamic_cast<const DefInit*>(ArgInit); if (!Arg) throw "Illegal operand for the '" + R->getName() + "' instruction!"; @@ -69,7 +69,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) { std::string EncoderMethod; std::string OperandType = "OPERAND_UNKNOWN"; unsigned NumOps = 1; - DagInit *MIOpInfo = 0; + const DagInit *MIOpInfo = 0; if (Rec->isSubClassOf("RegisterOperand")) { PrintMethod = Rec->getValueAsString("PrintMethod"); } else if (Rec->isSubClassOf("Operand")) { @@ -80,8 +80,8 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) { MIOpInfo = Rec->getValueAsDag("MIOperandInfo"); // Verify that MIOpInfo has an 'ops' root value. - if (!dynamic_cast<DefInit*>(MIOpInfo->getOperator()) || - dynamic_cast<DefInit*>(MIOpInfo->getOperator()) + if (!dynamic_cast<const DefInit*>(MIOpInfo->getOperator()) || + dynamic_cast<const DefInit*>(MIOpInfo->getOperator()) ->getDef()->getName() != "ops") throw "Bad value for MIOperandInfo in operand '" + Rec->getName() + "'\n"; @@ -182,7 +182,7 @@ CGIOperandList::ParseOperandName(const std::string &Op, bool AllowWholeOp) { } // Find the suboperand number involved. - DagInit *MIOpInfo = OperandList[OpIdx].MIOperandInfo; + const DagInit *MIOpInfo = OperandList[OpIdx].MIOperandInfo; if (MIOpInfo == 0) throw TheDef->getName() + ": unknown suboperand name in '" + Op + "'"; @@ -405,12 +405,12 @@ FlattenAsmStringVariants(StringRef Cur, unsigned Variant) { /// constructor. It checks if an argument in an InstAlias pattern matches /// the corresponding operand of the instruction. It returns true on a /// successful match, with ResOp set to the result operand to be used. -bool CodeGenInstAlias::tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo, +bool CodeGenInstAlias::tryAliasOpMatch(const DagInit *Result, unsigned AliasOpNo, Record *InstOpRec, bool hasSubOps, SMLoc Loc, CodeGenTarget &T, ResultOperand &ResOp) { - Init *Arg = Result->getArg(AliasOpNo); - DefInit *ADI = dynamic_cast<DefInit*>(Arg); + const Init *Arg = Result->getArg(AliasOpNo); + const DefInit *ADI = dynamic_cast<const 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 @@ bool CodeGenInstAlias::tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo, return true; } - if (IntInit *II = dynamic_cast<IntInit*>(Arg)) { + if (const IntInit *II = dynamic_cast<const IntInit*>(Arg)) { if (hasSubOps || !InstOpRec->isSubClassOf("Operand")) return false; // Integer arguments can't have names. @@ -475,7 +475,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) { Result = R->getValueAsDag("ResultInst"); // Verify that the root of the result is an instruction. - DefInit *DI = dynamic_cast<DefInit*>(Result->getOperator()); + const DefInit *DI = dynamic_cast<const 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 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) { // the same class. StringMap<Record*> NameClass; for (unsigned i = 0, e = Result->getNumArgs(); i != e; ++i) { - DefInit *ADI = dynamic_cast<DefInit*>(Result->getArg(i)); + const DefInit *ADI = dynamic_cast<const 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 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) { // If the argument did not match the instruction operand, and the operand // is composed of multiple suboperands, try matching the suboperands. if (NumSubOps > 1) { - DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo; + const 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<DefInit*>(MIOI->getArg(SubOp))->getDef(); + Record *SubRec = dynamic_cast<const DefInit*>(MIOI->getArg(SubOp))->getDef(); if (tryAliasOpMatch(Result, AliasOpNo, SubRec, false, R->getLoc(), T, ResOp)) { ResultOperands.push_back(ResOp); diff --git a/utils/TableGen/CodeGenInstruction.h b/utils/TableGen/CodeGenInstruction.h index 8d7669aca9..5cbe1400e7 100644 --- a/utils/TableGen/CodeGenInstruction.h +++ b/utils/TableGen/CodeGenInstruction.h @@ -98,7 +98,7 @@ namespace llvm { /// MIOperandInfo - Default MI operand type. Note an operand may be made /// up of multiple MI operands. - DagInit *MIOperandInfo; + const DagInit *MIOperandInfo; /// Constraint info for this operand. This operand can have pieces, so we /// track constraint info for each. @@ -106,7 +106,7 @@ namespace llvm { OperandInfo(Record *R, const std::string &N, const std::string &PMN, const std::string &EMN, const std::string &OT, unsigned MION, - unsigned MINO, DagInit *MIOI) + unsigned MINO, const DagInit *MIOI) : Rec(R), Name(N), PrinterMethodName(PMN), EncoderMethodName(EMN), OperandType(OT), MIOperandNo(MION), MINumOperands(MINO), MIOperandInfo(MIOI) {} @@ -270,7 +270,7 @@ namespace llvm { std::string AsmString; /// Result - The result instruction. - DagInit *Result; + const DagInit *Result; /// ResultInst - The instruction generated by the alias (decoded from /// Result). @@ -316,7 +316,7 @@ namespace llvm { CodeGenInstAlias(Record *R, CodeGenTarget &T); - bool tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo, + bool tryAliasOpMatch(const DagInit *Result, unsigned AliasOpNo, Record *InstOpRec, bool hasSubOps, SMLoc Loc, CodeGenTarget &T, ResultOperand &ResOp); }; diff --git a/utils/TableGen/CodeGenRegisters.cpp b/utils/TableGen/CodeGenRegisters.cpp index d7816c2c28..298009edc8 100644 --- a/utils/TableGen/CodeGenRegisters.cpp +++ b/utils/TableGen/CodeGenRegisters.cpp @@ -91,14 +91,14 @@ CodeGenRegister::getSubRegs(CodeGenRegBank &RegBank) { } // Process the composites. - ListInit *Comps = TheDef->getValueAsListInit("CompositeIndices"); + const ListInit *Comps = TheDef->getValueAsListInit("CompositeIndices"); for (unsigned i = 0, e = Comps->size(); i != e; ++i) { - DagInit *Pat = dynamic_cast<DagInit*>(Comps->getElement(i)); + const DagInit *Pat = dynamic_cast<const DagInit*>(Comps->getElement(i)); if (!Pat) throw TGError(TheDef->getLoc(), "Invalid dag '" + Comps->getElement(i)->getAsString() + "' in CompositeIndices"); - DefInit *BaseIdxInit = dynamic_cast<DefInit*>(Pat->getOperator()); + const DefInit *BaseIdxInit = dynamic_cast<const DefInit*>(Pat->getOperator()); if (!BaseIdxInit || !BaseIdxInit->getDef()->isSubClassOf("SubRegIndex")) throw TGError(TheDef->getLoc(), "Invalid SubClassIndex in " + Pat->getAsString()); @@ -107,7 +107,7 @@ CodeGenRegister::getSubRegs(CodeGenRegBank &RegBank) { CodeGenRegister *R2 = this; for (DagInit::const_arg_iterator di = Pat->arg_begin(), de = Pat->arg_end(); di != de; ++di) { - DefInit *IdxInit = dynamic_cast<DefInit*>(*di); + const DefInit *IdxInit = dynamic_cast<const DefInit*>(*di); if (!IdxInit || !IdxInit->getDef()->isSubClassOf("SubRegIndex")) throw TGError(TheDef->getLoc(), "Invalid SubClassIndex in " + Pat->getAsString()); @@ -163,7 +163,7 @@ struct TupleExpander : SetTheory::Expander { void expand(SetTheory &ST, Record *Def, SetTheory::RecSet &Elts) { std::vector<Record*> Indices = Def->getValueAsListOfDefs("SubRegIndices"); unsigned Dim = Indices.size(); - ListInit *SubRegs = Def->getValueAsListInit("SubRegs"); + const 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 @@ struct TupleExpander : SetTheory::Expander { // Precompute some types. Record *RegisterCl = Def->getRecords().getClass("Register"); RecTy *RegisterRecTy = RecordRecTy::get(RegisterCl); - StringInit *BlankName = new StringInit(""); + const StringInit *BlankName = new StringInit(""); // Zip them up. for (unsigned n = 0; n != Length; ++n) { std::string Name; Record *Proto = Lists[0][n]; - std::vector<Init*> Tuple; + std::vector<const Init*> Tuple; unsigned CostPerUse = 0; for (unsigned i = 0; i != Dim; ++i) { Record *Reg = Lists[i][n]; @@ -278,7 +278,7 @@ CodeGenRegisterClass::CodeGenRegisterClass(CodeGenRegBank &RegBank, Record *R) Members.insert(RegBank.getReg((*Elements)[i])); // Alternative allocation orders may be subsets. - ListInit *Alts = R->getValueAsListInit("AltOrders"); + const 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 @@ CodeGenRegisterClass::CodeGenRegisterClass(CodeGenRegBank &RegBank, Record *R) } // SubRegClasses is a list<dag> containing (RC, subregindex, ...) dags. - ListInit *SRC = R->getValueAsListInit("SubRegClasses"); + const ListInit *SRC = R->getValueAsListInit("SubRegClasses"); for (ListInit::const_iterator i = SRC->begin(), e = SRC->end(); i != e; ++i) { - DagInit *DAG = dynamic_cast<DagInit*>(*i); + const DagInit *DAG = dynamic_cast<const DagInit*>(*i); if (!DAG) throw "SubRegClasses must contain DAGs"; - DefInit *DAGOp = dynamic_cast<DefInit*>(DAG->getOperator()); + const DefInit *DAGOp = dynamic_cast<const DefInit*>(DAG->getOperator()); Record *RCRec; if (!DAGOp || !(RCRec = DAGOp->getDef())->isSubClassOf("RegisterClass")) throw "Operator '" + DAG->getOperator()->getAsString() + @@ -307,7 +307,7 @@ CodeGenRegisterClass::CodeGenRegisterClass(CodeGenRegBank &RegBank, Record *R) // Iterate over args, all SubRegIndex instances. for (DagInit::const_arg_iterator ai = DAG->arg_begin(), ae = DAG->arg_end(); ai != ae; ++ai) { - DefInit *Idx = dynamic_cast<DefInit*>(*ai); + const DefInit *Idx = dynamic_cast<const DefInit*>(*ai); Record *IdxRec; if (!Idx || !(IdxRec = Idx->getDef())->isSubClassOf("SubRegIndex")) throw "Argument '" + (*ai)->getAsString() + diff --git a/utils/TableGen/CodeGenTarget.cpp b/utils/TableGen/CodeGenTarget.cpp index 929791c318..ceaa82fa05 100644 --- a/utils/TableGen/CodeGenTarget.cpp +++ b/utils/TableGen/CodeGenTarget.cpp @@ -402,7 +402,7 @@ CodeGenIntrinsic::CodeGenIntrinsic(Record *R) { // Parse the list of return types. std::vector<MVT::SimpleValueType> OverloadedVTs; - ListInit *TypeList = R->getValueAsListInit("RetTypes"); + const ListInit *TypeList = R->getValueAsListInit("RetTypes"); for (unsigned i = 0, e = TypeList->getSize(); i != e; ++i) { Record *TyEl = TypeList->getElementAsRecord(i); assert(TyEl->isSubClassOf("LLVMType") && "Expected a type!"); @@ -470,7 +470,7 @@ CodeGenIntrinsic::CodeGenIntrinsic(Record *R) { } // Parse the intrinsic properties. - ListInit *PropList = R->getValueAsListInit("Properties"); + const ListInit *PropList = R->getValueAsListInit("Properties"); for (unsigned i = 0, e = PropList->getSize(); i != e; ++i) { Record *Property = PropList->getElementAsRecord(i); assert(Property->isSubClassOf("IntrinsicProperty") && diff --git a/utils/TableGen/DAGISelMatcherGen.cpp b/utils/TableGen/DAGISelMatcherGen.cpp index c5897c72d3..7e66c05a93 100644 --- a/utils/TableGen/DAGISelMatcherGen.cpp +++ b/utils/TableGen/DAGISelMatcherGen.cpp @@ -203,7 +203,7 @@ void MatcherGen::EmitLeafMatchCode(const TreePatternNode *N) { assert(N->isLeaf() && "Not a leaf?"); // Direct match against an integer constant. - if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) { + if (const IntInit *II = dynamic_cast<const IntInit*>(N->getLeafValue())) { // If this is the root of the dag we're matching, we emit a redundant opcode // check to ensure that this gets folded into the normal top-level // OpcodeSwitch. @@ -215,7 +215,7 @@ void MatcherGen::EmitLeafMatchCode(const TreePatternNode *N) { return AddMatcher(new CheckIntegerMatcher(II->getValue())); } - DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue()); + const DefInit *DI = dynamic_cast<const DefInit*>(N->getLeafValue()); if (DI == 0) { errs() << "Unknown leaf kind: " << *DI << "\n"; abort(); @@ -283,7 +283,7 @@ void MatcherGen::EmitOperatorMatchCode(const TreePatternNode *N, N->getOperator()->getName() == "or") && N->getChild(1)->isLeaf() && N->getChild(1)->getPredicateFns().empty() && N->getPredicateFns().empty()) { - if (IntInit *II = dynamic_cast<IntInit*>(N->getChild(1)->getLeafValue())) { + if (const IntInit *II = dynamic_cast<const 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 @@ bool MatcherGen::EmitMatcherCode(unsigned Variant) { --RecNodeEntry; // Entries in VariableMap are biased. const ComplexPattern &CP = - CGP.getComplexPattern(((DefInit*)N->getLeafValue())->getDef()); + CGP.getComplexPattern(((const 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 @@ void MatcherGen::EmitResultLeafAsOperand(const TreePatternNode *N, SmallVectorImpl<unsigned> &ResultOps) { assert(N->isLeaf() && "Must be a leaf"); - if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) { + if (const IntInit *II = dynamic_cast<const 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 (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) { + if (const DefInit *DI = dynamic_cast<const DefInit*>(N->getLeafValue())) { Record *Def = DI->getDef(); if (Def->isSubClassOf("Register")) { const CodeGenRegister *Reg = diff --git a/utils/TableGen/FastISelEmitter.cpp b/utils/TableGen/FastISelEmitter.cpp index f54e8df40f..2a86b896c0 100644 --- a/utils/TableGen/FastISelEmitter.cpp +++ b/utils/TableGen/FastISelEmitter.cpp @@ -241,7 +241,7 @@ struct OperandsSignature { if (Op->getType(0) != VT) return false; - DefInit *OpDI = dynamic_cast<DefInit*>(Op->getLeafValue()); + const DefInit *OpDI = dynamic_cast<const DefInit*>(Op->getLeafValue()); if (!OpDI) return false; Record *OpLeafRec = OpDI->getDef(); @@ -401,12 +401,12 @@ static std::string PhyRegForNode(TreePatternNode *Op, if (!Op->isLeaf()) return PhysReg; - DefInit *OpDI = dynamic_cast<DefInit*>(Op->getLeafValue()); + const DefInit *OpDI = dynamic_cast<const DefInit*>(Op->getLeafValue()); Record *OpLeafRec = OpDI->getDef(); if (!OpLeafRec->isSubClassOf("Register")) return PhysReg; - PhysReg += static_cast<StringInit*>(OpLeafRec->getValue( \ + PhysReg += static_cast<const StringInit*>(OpLeafRec->getValue( \ "Namespace")->getValue())->getValue(); PhysReg += "::"; PhysReg += Target.getRegBank().getReg(OpLeafRec)->getName(); @@ -468,7 +468,7 @@ void FastISelMap::collectPatterns(CodeGenDAGPatterns &CGP) { // a bit too complicated for now. if (!Dst->getChild(1)->isLeaf()) continue; - DefInit *SR = dynamic_cast<DefInit*>(Dst->getChild(1)->getLeafValue()); + const DefInit *SR = dynamic_cast<const DefInit*>(Dst->getChild(1)->getLeafValue()); if (SR) SubRegNo = getQualifiedName(SR->getDef()); else diff --git a/utils/TableGen/FixedLenDecoderEmitter.cpp b/utils/TableGen/FixedLenDecoderEmitter.cpp index 8091003288..c254069210 100644 --- a/utils/TableGen/FixedLenDecoderEmitter.cpp +++ b/utils/TableGen/FixedLenDecoderEmitter.cpp @@ -48,15 +48,15 @@ static bool ValueNotSet(bit_value_t V) { static int Value(bit_value_t V) { return ValueNotSet(V) ? -1 : (V == BIT_FALSE ? 0 : 1); } -static bit_value_t bitFromBits(BitsInit &bits, unsigned index) { - if (BitInit *bit = dynamic_cast<BitInit*>(bits.getBit(index))) +static bit_value_t bitFromBits(const BitsInit &bits, unsigned index) { + if (const BitInit *bit = dynamic_cast<const 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, BitsInit &bits) { +static void dumpBits(raw_ostream &o, const BitsInit &bits) { unsigned index; for (index = bits.getNumBits(); index > 0; index--) { @@ -76,8 +76,8 @@ static void dumpBits(raw_ostream &o, BitsInit &bits) { } } -static BitsInit &getBitsField(const Record &def, const char *str) { - BitsInit *bits = def.getValueAsBitsInit(str); +static const BitsInit &getBitsField(const Record &def, const char *str) { + const BitsInit *bits = def.getValueAsBitsInit(str); return *bits; } @@ -277,7 +277,7 @@ public: protected: // Populates the insn given the uid. void insnWithID(insn_t &Insn, unsigned Opcode) const { - BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef, "Inst"); + const BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef, "Inst"); for (unsigned i = 0; i < BitWidth; ++i) Insn.push_back(bitFromBits(Bits, i)); @@ -1194,7 +1194,7 @@ static bool populateInstruction(const CodeGenInstruction &CGI, Def.getValueAsBit("isCodeGenOnly")) return false; - BitsInit &Bits = getBitsField(Def, "Inst"); + const BitsInit &Bits = getBitsField(Def, "Inst"); if (Bits.allInComplete()) return false; std::vector<OperandInfo> InsnOperands; @@ -1215,9 +1215,9 @@ static bool populateInstruction(const CodeGenInstruction &CGI, // Gather the outputs/inputs of the instruction, so we can find their // positions in the encoding. This assumes for now that they appear in the // MCInst in the order that they're listed. - std::vector<std::pair<Init*, std::string> > InOutOperands; - DagInit *Out = Def.getValueAsDag("OutOperandList"); - DagInit *In = Def.getValueAsDag("InOperandList"); + std::vector<std::pair<const Init*, std::string> > InOutOperands; + const DagInit *Out = Def.getValueAsDag("OutOperandList"); + const 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 @@ static bool populateInstruction(const CodeGenInstruction &CGI, } // For each operand, see if we can figure out where it is encoded. - for (std::vector<std::pair<Init*, std::string> >::iterator + for (std::vector<std::pair<const Init*, std::string> >::iterator NI = InOutOperands.begin(), NE = InOutOperands.end(); NI != NE; ++NI) { std::string Decoder = ""; @@ -1244,7 +1244,7 @@ static bool populateInstruction(const CodeGenInstruction &CGI, // for decoding register classes. // FIXME: This need to be extended to handle instructions with custom // decoder methods, and operands with (simple) MIOperandInfo's. - TypedInit *TI = dynamic_cast<TypedInit*>(NI->first); + const TypedInit *TI = dynamic_cast<const TypedInit*>(NI->first); RecordRecTy *Type = dynamic_cast<RecordRecTy*>(TI->getType()); Record *TypeRecord = Type->getRecord(); bool isReg = false; @@ -1256,8 +1256,8 @@ static bool populateInstruction(const CodeGenInstruction &CGI, } RecordVal *DecoderString = TypeRecord->getValue("DecoderMethod"); - StringInit *String = DecoderString ? - dynamic_cast<StringInit*>(DecoderString->getValue()) : 0; + const StringInit *String = DecoderString ? + dynamic_cast<const StringInit*>(DecoderString->getValue()) : 0; if (!isReg && String && String->getValue() != "") Decoder = String->getValue(); @@ -1267,7 +1267,7 @@ static bool populateInstruction(const CodeGenInstruction &CGI, unsigned Offset = 0; for (unsigned bi = 0; bi < Bits.getNumBits(); ++bi) { - VarBitInit *BI = dynamic_cast<VarBitInit*>(Bits.getBit(bi)); + const VarBitInit *BI = dynamic_cast<const VarBitInit*>(Bits.getBit(bi)); if (!BI) { if (Base != ~0U) { OpInfo.addField(Base, Width, Offset); @@ -1277,8 +1277,9 @@ static bool populateInstruction(const CodeGenInstruction &CGI, } continue; } + if (!BI) continue; - VarInit *Var = dynamic_cast<VarInit*>(BI->getVariable()); + const VarInit *Var = dynamic_cast<const VarInit*>(BI->getVariable()); assert(Var); if (Var->getName() != NI->second && Var->getName() != TiedNames[NI->second]) { diff --git a/utils/TableGen/InstrInfoEmitter.cpp b/utils/TableGen/InstrInfoEmitter.cpp index 5ebaf17465..5004a99228 100644 --- a/utils/TableGen/InstrInfoEmitter.cpp +++ b/utils/TableGen/InstrInfoEmitter.cpp @@ -61,7 +61,7 @@ InstrInfoEmitter::GetOperandInfo(const CodeGenInstruction &Inst) { // registers in their multi-operand operands. It may also be an anonymous // operand, which has a single operand, but no declared class for the // operand. - DagInit *MIOI = Inst.Operands[i].MIOperandInfo; + const DagInit *MIOI = Inst.Operands[i].MIOperandInfo; if (!MIOI || MIOI->getNumArgs() == 0) { // Single, anonymous, operand. @@ -70,7 +70,7 @@ InstrInfoEmitter::GetOperandInfo(const CodeGenInstruction &Inst) { for (unsigned j = 0, e = Inst.Operands[i].MINumOperands; j != e; ++j) { OperandList.push_back(Inst.Operands[i]); - Record *OpR = dynamic_cast<DefInit*>(MIOI->getArg(j))->getDef(); + Record *OpR = dynamic_cast<const DefInit*>(MIOI->getArg(j))->getDef(); OperandList.back().Rec = OpR; } } @@ -295,11 +295,11 @@ void InstrInfoEmitter::emitRecord(const CodeGenInstruction &Inst, unsigned Num, if (Inst.hasExtraDefRegAllocReq) OS << "|(1<<MCID::ExtraDefRegAllocReq)"; // Emit all of the target-specific flags... - BitsInit *TSF = Inst.TheDef->getValueAsBitsInit("TSFlags"); + const 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 (BitInit *Bit = dynamic_cast<BitInit*>(TSF->getBit(i))) + if (const BitInit *Bit = dynamic_cast<const BitInit*>(TSF->getBit(i))) Value |= uint64_t(Bit->getValue()) << i; else throw "Invalid TSFlags bit in " + Inst.TheDef->getName(); diff --git a/utils/TableGen/LLVMCConfigurationEmitter.cpp b/utils/TableGen/LLVMCConfigurationEmitter.cpp index cd0cbeb1c6..563a72789d 100644 --- a/utils/TableGen/LLVMCConfigurationEmitter.cpp +++ b/utils/TableGen/LLVMCConfigurationEmitter.cpp @@ -245,7 +245,7 @@ struct OptionDescription { unsigned Flags; std::string Help; unsigned MultiVal; - Init* InitVal; + const Init* InitVal; OptionDescription(OptionType::OptionType t = OptionType::Switch, const std::string& n = "", @@ -589,7 +589,7 @@ Handler GetHandler(FunctionObject* Obj, const DagInit& Dag) { } template <class FunctionObject> -void InvokeDagInitHandler(FunctionObject* Obj, Init* I) { +void InvokeDagInitHandler(FunctionObject* Obj, const Init* I) { typedef void (FunctionObject::*Handler) (const DagInit&); const DagInit& Dag = InitPtrToDag(I); @@ -658,7 +658,7 @@ public: /// operator() - Just forwards to the corresponding property /// handler. - void operator() (Init* I) { + void operator() (const Init* I) { InvokeDagInitHandler(this, I); } @@ -705,10 +705,10 @@ private: void onInit (const DagInit& d) { CheckNumberOfArguments(d, 1); - Init* i = d.getArg(0); + const Init* i = d.getArg(0); const std::string& str = i->getAsString(); - bool correct = optDesc_.isParameter() && dynamic_cast<StringInit*>(i); + bool correct = optDesc_.isParameter() && dynamic_cast<const StringInit*>(i); correct |= (optDesc_.isSwitch() && (str == "true" || str == "false")); if (!correct) @@ -821,7 +821,7 @@ void CollectOptionDescriptions (const RecordVector& V, for (RecordVector::const_iterator B = V.begin(), E = V.end(); B!=E; ++B) { // Throws an exception if the value does not exist. - ListInit* PropList = (*B)->getValueAsListInit("options"); + const ListInit* PropList = (*B)->getValueAsListInit("options"); // For every option description in this list: invoke AddOption. std::for_each(PropList->begin(), PropList->end(), AddOption(OptDescs)); @@ -836,8 +836,8 @@ namespace ToolFlags { struct ToolDescription : public RefCountedBase<ToolDescription> { std::string Name; - Init* CmdLine; - Init* Actions; + const Init* CmdLine; + const Init* Actions; StrVector InLanguage; std::string InFileOption; std::string OutFileOption; @@ -903,7 +903,7 @@ public: } } - void operator() (Init* I) { + void operator() (const Init* I) { InvokeDagInitHandler(this, I); } @@ -915,9 +915,9 @@ private: void onActions (const DagInit& d) { CheckNumberOfArguments(d, 1); - Init* Case = d.getArg(0); + const Init* Case = d.getArg(0); if (typeid(*Case) != typeid(DagInit) || - GetOperatorName(static_cast<DagInit&>(*Case)) != "case") + GetOperatorName(static_cast<const DagInit&>(*Case)) != "case") throw "The argument to (actions) should be a 'case' construct!"; toolDesc_.Actions = Case; } @@ -954,7 +954,7 @@ private: isReallyJoin = true; } else { - Init* I = d.getArg(0); + const Init* I = d.getArg(0); isReallyJoin = InitPtrToBool(I); } @@ -1007,7 +1007,7 @@ void CollectToolDescriptions (const RecordVector& Tools, E = Tools.end(); B!=E; ++B) { const Record* T = *B; // Throws an exception if the value does not exist. - ListInit* PropList = T->getValueAsListInit("properties"); + const ListInit* PropList = T->getValueAsListInit("properties"); IntrusiveRefCntPtr<ToolDescription> ToolDesc(new ToolDescription(T->getName())); @@ -1163,7 +1163,7 @@ void WalkCase(const Init* Case, F1 TestCallback, F2 StatementCallback, unsigned i = 1; for (DagInit::const_arg_iterator B = d.arg_begin(), E = d.arg_end(); B != E; ++B) { - Init* arg = *B; + const Init* arg = *B; if (!even) { @@ -1181,8 +1181,8 @@ void WalkCase(const Init* Case, F1 TestCallback, F2 StatementCallback, } else { - if (dynamic_cast<DagInit*>(arg) - && GetOperatorName(static_cast<DagInit&>(*arg)) == "case") { + if (dynamic_cast<const DagInit*>(arg) + && GetOperatorName(static_cast<const DagInit&>(*arg)) == "case") { // Nested 'case'. WalkCase(arg, TestCallback, StatementCallback, IndentLevel + Indent1); } @@ -1210,7 +1210,7 @@ class ExtractOptionNames { ActionName == "parameter_equals" || ActionName == "element_in_list") { CheckNumberOfArguments(Stmt, 1); - Init* Arg = Stmt.getArg(0); + const Init* Arg = Stmt.getArg(0); if (typeid(*Arg) == typeid(StringInit)) OptionNames_.insert(InitPtrToString(Arg)); } @@ -1218,7 +1218,7 @@ class ExtractOptionNames { ActionName == "any_not_empty" || ActionName == "any_empty" || ActionName == "not_empty" || ActionName == "empty") { for (unsigned i = 0, NumArgs = Stmt.getNumArgs(); i < NumArgs; ++i) { - Init* Arg = Stmt.getArg(i); + const Init* Arg = Stmt.getArg(i); if (typeid(*Arg) == typeid(StringInit)) OptionNames_.insert(InitPtrToString(Arg)); } @@ -2613,7 +2613,7 @@ void EmitPreprocessOptions (const RecordKeeper& Records, for (RecordVector::const_iterator B = OptionPreprocessors.begin(), E = OptionPreprocessors.end(); B!=E; ++B) { - DagInit* Case = (*B)->getValueAsDag("preprocessor"); + const DagInit* Case = (*B)->getValueAsDag("preprocessor"); EmitCaseConstructHandler(Case, Indent1, EmitPreprocessOptionsCallback(OptDecs), false, OptDecs, O); @@ -2645,7 +2645,7 @@ public: } } - void operator() (Init* I) { + void operator() (const Init* I) { InvokeDagInitHandler(this, I); } @@ -2655,7 +2655,7 @@ private: CheckNumberOfArguments(d, 2); const std::string& Lang = InitPtrToString(d.getArg(0)); - Init* Suffixes = d.getArg(1); + const Init* Suffixes = d.getArg(1); // Second argument to lang_to_suffixes is either a single string... if (typeid(*Suffixes) == typeid(StringInit)) { @@ -2688,7 +2688,7 @@ void EmitPopulateLanguageMap (const RecordKeeper& Records, raw_ostream& O) // Call DoEmitPopulateLanguageMap. for (RecordVector::const_iterator B = LangMaps.begin(), E = LangMaps.end(); B!=E; ++B) { - ListInit* LangMap = (*B)->getValueAsListInit("map"); + const ListInit* LangMap = (*B)->getValueAsListInit("map"); std::for_each(LangMap->begin(), LangMap->end(), DoEmitPopulateLanguageMap(O)); } @@ -2947,7 +2947,7 @@ void FillInHookNames(const ToolDescriptions& ToolDescs, // Look for hook invocations in 'cmd_line'. if (!D.CmdLine) continue; - if (dynamic_cast<StringInit*>(D.CmdLine)) + if (dynamic_cast<const StringInit*>(D.CmdLine)) // This is a string. ExtractHookNames(HookNames, OptDescs).operator()(D.CmdLine); else diff --git a/utils/TableGen/OptParserEmitter.cpp b/utils/TableGen/OptParserEmitter.cpp index 431026c669..f4d7be52db 100644 --- a/utils/TableGen/OptParserEmitter.cpp +++ b/utils/TableGen/OptParserEmitter.cpp @@ -56,7 +56,7 @@ static int CompareOptionRecords(const void *Av, const void *Bv) { static const std::string getOptionName(const Record &R) { // Use the record name unless EnumName is defined. - if (dynamic_cast<UnsetInit*>(R.getValueInit("EnumName"))) + if (dynamic_cast<const UnsetInit*>(R.getValueInit("EnumName"))) return R.getName(); return R.getValueAsString("EnumName"); @@ -105,7 +105,7 @@ void OptParserEmitter::run(raw_ostream &OS) { // The containing option group (if any). OS << ", "; - if (const DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group"))) + if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Group"))) OS << getOptionName(*DI->getDef()); else OS << "INVALID"; @@ -114,7 +114,7 @@ void OptParserEmitter::run(raw_ostream &OS) { OS << ", INVALID, 0, 0"; // The option help text. - if (!dynamic_cast<UnsetInit*>(R.getValueInit("HelpText"))) { + if (!dynamic_cast<const UnsetInit*>(R.getValueInit("HelpText"))) { OS << ",\n"; OS << " "; write_cstring(OS, R.getValueAsString("HelpText")); @@ -145,14 +145,14 @@ void OptParserEmitter::run(raw_ostream &OS) { // The containing option group (if any). OS << ", "; - if (const DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group"))) + if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Group"))) OS << getOptionName(*DI->getDef()); else OS << "INVALID"; // The option alias (if any). OS << ", "; - if (const DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Alias"))) + if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Alias"))) OS << getOptionName(*DI->getDef()); else OS << "INVALID"; @@ -166,7 +166,7 @@ void OptParserEmitter::run(raw_ostream &OS) { for (unsigned i = 0, e = LI->size(); i != e; ++i) { if (i) OS << " | "; - OS << dynamic_cast<DefInit*>(LI->getElement(i))->getDef()->getName(); + OS << dynamic_cast<const DefInit*>(LI->getElement(i))->getDef()->getName(); } } @@ -174,7 +174,7 @@ void OptParserEmitter::run(raw_ostream &OS) { OS << ", " << R.getValueAsInt("NumArgs"); // The option help text. - if (!dynamic_cast<UnsetInit*>(R.getValueInit("HelpText"))) { + if (!dynamic_cast<const UnsetInit*>(R.getValueInit("HelpText"))) { OS << ",\n"; OS << " "; write_cstring(OS, R.getValueAsString("HelpText")); @@ -183,7 +183,7 @@ void OptParserEmitter::run(raw_ostream &OS) { // The option meta-variable name. OS << ", "; - if (!dynamic_cast<UnsetInit*>(R.getValueInit("MetaVarName"))) + if (!dynamic_cast<const UnsetInit*>(R.getValueInit("MetaVarName"))) write_cstring(OS, R.getValueAsString("MetaVarName")); else OS << "0"; diff --git a/utils/TableGen/PseudoLoweringEmitter.cpp b/utils/TableGen/PseudoLoweringEmitter.cpp index db33c1f7f6..5cfa587f1d 100644 --- a/utils/TableGen/PseudoLoweringEmitter.cpp +++ b/utils/TableGen/PseudoLoweringEmitter.cpp @@ -24,11 +24,11 @@ using namespace llvm; // a single dag, so we can do fancier things. unsigned PseudoLoweringEmitter:: -addDagOperandMapping(Record *Rec, DagInit *Dag, CodeGenInstruction &Insn, +addDagOperandMapping(Record *Rec, const DagInit *Dag, CodeGenInstruction &Insn, IndexedMap<OpData> &OperandMap, unsigned BaseIdx) { unsigned OpsAdded = 0; for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) { - if (DefInit *DI = dynamic_cast<DefInit*>(Dag->getArg(i))) { + if (const DefInit *DI = dynamic_cast<const 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 @@ addDagOperandMapping(Record *Rec, DagInit *Dag, CodeGenInstruction &Insn, for (unsigned I = 0, E = Insn.Operands[i].MINumOperands; I != E; ++I) OperandMap[BaseIdx + i + I].Kind = OpData::Operand; OpsAdded += Insn.Operands[i].MINumOperands; - } else if (IntInit *II = dynamic_cast<IntInit*>(Dag->getArg(i))) { + } else if (const IntInit *II = dynamic_cast<const IntInit*>(Dag->getArg(i))) { OperandMap[BaseIdx + i].Kind = OpData::Imm; OperandMap[BaseIdx + i].Data.Imm = II->getValue(); ++OpsAdded; - } else if (DagInit *SubDag = dynamic_cast<DagInit*>(Dag->getArg(i))) { + } else if (const DagInit *SubDag = dynamic_cast<const 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 @@ void PseudoLoweringEmitter::evaluateExpansion(Record *Rec) { // Validate that the result pattern has the corrent number and types // of arguments for the instruction it references. - DagInit *Dag = Rec->getValueAsDag("ResultInst"); + const DagInit *Dag = Rec->getValueAsDag("ResultInst"); assert(Dag && "Missing result instruction in pseudo expansion!"); DEBUG(dbgs() << " Result: " << *Dag << "\n"); - DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator()); + const DefInit *OpDef = dynamic_cast<const DefInit*>(Dag->getOperator()); if (!OpDef) throw TGError(Rec->getLoc(), Rec->getName() + " has unexpected operator type!"); diff --git a/utils/TableGen/PseudoLoweringEmitter.h b/utils/TableGen/PseudoLoweringEmitter.h index 2749280e6a..6e52638187 100644 --- a/utils/TableGen/PseudoLoweringEmitter.h +++ b/utils/TableGen/PseudoLoweringEmitter.h @@ -47,7 +47,7 @@ class PseudoLoweringEmitter : public TableGenBackend { SmallVector<PseudoExpansion, 64> Expansions; - unsigned addDagOperandMapping(Record *Rec, DagInit *Dag, + unsigned addDagOperandMapping(Record *Rec, const DagInit *Dag, CodeGenInstruction &Insn, IndexedMap<OpData> &OperandMap, unsigned BaseIdx); diff --git a/utils/TableGen/Record.cpp b/utils/TableGen/Record.cpp index 4f33638eaa..e2f505e17e 100644 --- a/utils/TableGen/Record.cpp +++ b/utils/TableGen/Record.cpp @@ -85,7 +85,7 @@ ListRecTy *RecTy::getListTy() { return ListTy; } -Init *BitRecTy::convertValue(BitsInit *BI) { +const Init *BitRecTy::convertValue(const BitsInit *BI) { if (BI->getNumBits() != 1) return 0; // Only accept if just one bit! return BI->getBit(0); } @@ -94,14 +94,14 @@ bool BitRecTy::baseClassOf(const BitsRecTy *RHS) const { return RHS->getNumBits() == 1; } -Init *BitRecTy::convertValue(IntInit *II) { +const Init *BitRecTy::convertValue(const IntInit *II) { int64_t Val = II->getValue(); if (Val != 0 && Val != 1) return 0; // Only accept 0 or 1 for a bit! return new BitInit(Val != 0); } -Init *BitRecTy::convertValue(TypedInit *VI) { +const Init *BitRecTy::convertValue(const TypedInit *VI) { if (dynamic_cast<BitRecTy*>(VI->getType())) return VI; // Accept variable if it is already of bit type! return 0; @@ -121,18 +121,18 @@ std::string BitsRecTy::getAsString() const { return "bits<" + utostr(Size) + ">"; } -Init *BitsRecTy::convertValue(UnsetInit *UI) { - SmallVector<Init *, 16> NewBits(Size); +const Init *BitsRecTy::convertValue(const UnsetInit *UI) { + SmallVector<const Init *, 16> NewBits(Size); for (unsigned i = 0; i != Size; ++i) NewBits[i] = new UnsetInit(); - return new BitsInit(ArrayRef<Init *>(NewBits)); + return new BitsInit(ArrayRef<const Init *>(NewBits)); } -Init *BitsRecTy::convertValue(BitInit *UI) { +const Init *BitsRecTy::convertValue(const BitInit *UI) { if (Size != 1) return 0; // Can only convert single bit. - return new BitsInit(ArrayRef<Init *>(UI)); + return new BitsInit(ArrayRef<const Init *>(UI)); } /// canFitInBitfield - Return true if the number of bits is large enough to hold @@ -146,55 +146,55 @@ static bool canFitInBitfield(int64_t Value, unsigned NumBits) { /// convertValue from Int initializer to bits type: Split the integer up into the /// appropriate bits. /// -Init *BitsRecTy::convertValue(IntInit *II) { +const Init *BitsRecTy::convertValue(const 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<Init *, 16> NewBits(Size); + SmallVector<const Init *, 16> NewBits(Size); for (unsigned i = 0; i != Size; ++i) NewBits[i] = new BitInit(Value & (1LL << i)); - return new BitsInit(ArrayRef<Init *>(NewBits)); + return new BitsInit(ArrayRef<const Init *>(NewBits)); } -Init *BitsRecTy::convertValue(BitsInit *BI) { +const Init *BitsRecTy::convertValue(const 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; } -Init *BitsRecTy::convertValue(TypedInit *VI) { +const Init *BitsRecTy::convertValue(const TypedInit *VI) { if (BitsRecTy *BRT = dynamic_cast<BitsRecTy*>(VI->getType())) if (BRT->Size == Size) { - SmallVector<Init *, 16> NewBits(Size); + SmallVector<const Init *, 16> NewBits(Size); for (unsigned i = 0; i != Size; ++i) NewBits[i] = new VarBitInit(VI, i); - return new BitsInit(ArrayRef<Init *>(NewBits)); + return new BitsInit(ArrayRef<const Init *>(NewBits)); } if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType())) - return new BitsInit(VI); + return new BitsInit(ArrayRef<const Init *>(VI)); - if (TernOpInit *Tern = dynamic_cast<TernOpInit*>(VI)) { + if (const TernOpInit *Tern = dynamic_cast<const TernOpInit*>(VI)) { if (Tern->getOpcode() == TernOpInit::IF) { - Init *LHS = Tern->getLHS(); - Init *MHS = Tern->getMHS(); - Init *RHS = Tern->getRHS(); + const Init *LHS = Tern->getLHS(); + const Init *MHS = Tern->getMHS(); + const Init *RHS = Tern->getRHS(); - IntInit *MHSi = dynamic_cast<IntInit*>(MHS); - IntInit *RHSi = dynamic_cast<IntInit*>(RHS); + const IntInit *MHSi = dynamic_cast<const IntInit*>(MHS); + const IntInit *RHSi = dynamic_cast<const IntInit*>(RHS); if (MHSi && RHSi) { int64_t MHSVal = MHSi->getValue(); int64_t RHSVal = RHSi->getValue(); if (canFitInBitfield(MHSVal, Size) && canFitInBitfield(RHSVal, Size)) { - SmallVector<Init *, 16> NewBits(Size); + SmallVector<const Init *, 16> NewBits(Size); for (unsigned i = 0; i != Size; ++i) NewBits[i] = @@ -203,14 +203,14 @@ Init *BitsRecTy::convertValue(TypedInit *VI) { new IntInit((RHSVal & (1LL << i)) ? 1 : 0), VI->getType()); - return new BitsInit(ArrayRef<Init *>(NewBits)); + return new BitsInit(ArrayRef<const Init *>(NewBits)); } } else { - BitsInit *MHSbs = dynamic_cast<BitsInit*>(MHS); - BitsInit *RHSbs = dynamic_cast<BitsInit*>(RHS); + const BitsInit *MHSbs = dynamic_cast<const BitsInit*>(MHS); + const BitsInit *RHSbs = dynamic_cast<const BitsInit*>(RHS); if (MHSbs && RHSbs) { - SmallVector<Init *, 16> NewBits(Size); + SmallVector<const Init *, 16> NewBits(Size); for (unsigned i = 0; i != Size; ++i) NewBits[i] = new TernOpInit(TernOpInit::IF, LHS, @@ -218,7 +218,7 @@ Init *BitsRecTy::convertValue(TypedInit *VI) { RHSbs->getBit(i), VI->getType()); - return new BitsInit(ArrayRef<Init *>(NewBits)); + return new BitsInit(ArrayRef<const Init *>(NewBits)); } } } @@ -227,14 +227,14 @@ Init *BitsRecTy::convertValue(TypedInit *VI) { return 0; } -Init *IntRecTy::convertValue(BitInit *BI) { +const Init *IntRecTy::convertValue(const BitInit *BI) { return new IntInit(BI->getValue()); } -Init *IntRecTy::convertValue(BitsInit *BI) { +const Init *IntRecTy::convertValue(const BitsInit *BI) { int64_t Result = 0; for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) - if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) { + if (const BitInit *Bit = dynamic_cast<const BitInit*>(BI->getBit(i))) { Result |= Bit->getValue() << i; } else { return 0; @@ -242,39 +242,39 @@ Init *IntRecTy::convertValue(BitsInit *BI) { return new IntInit(Result); } -Init *IntRecTy::convertValue(TypedInit *TI) { +const Init *IntRecTy::convertValue(const TypedInit *TI) { if (TI->getType()->typeIsConvertibleTo(this)) return TI; // Accept variable if already of the right type! return 0; } -Init *StringRecTy::convertValue(UnOpInit *BO) { +const Init *StringRecTy::convertValue(const UnOpInit *BO) { if (BO->getOpcode() == UnOpInit::CAST) { - Init *L = BO->getOperand()->convertInitializerTo(this); + const Init *L = BO->getOperand()->convertInitializerTo(this); if (L == 0) return 0; if (L != BO->getOperand()) return new UnOpInit(UnOpInit::CAST, L, new StringRecTy); return BO; } - return convertValue((TypedInit*)BO); + return convertValue((const TypedInit*)BO); } -Init *StringRecTy::convertValue(BinOpInit *BO) { +const Init *StringRecTy::convertValue(const BinOpInit *BO) { if (BO->getOpcode() == BinOpInit::STRCONCAT) { - Init *L = BO->getLHS()->convertInitializerTo(this); - Init *R = BO->getRHS()->convertInitializerTo(this); + const Init *L = BO->getLHS()->convertInitializerTo(this); + const Init *R = BO->getRHS()->convertInitializerTo(this); if (L == 0 || R == 0) return 0; if (L != BO->getLHS() || R != BO->getRHS()) return new BinOpInit(BinOpInit::STRCONCAT, L, R, new StringRecTy); return BO; } - return convertValue((TypedInit*)BO); + return convertValue((const TypedInit*)BO); } -Init *StringRecTy::convertValue(TypedInit *TI) { +const Init *StringRecTy::convertValue(const TypedInit *TI) { if (dynamic_cast<StringRecTy*>(TI->getType())) return TI; // Accept variable if already of the right type! return 0; @@ -284,13 +284,13 @@ std::string ListRecTy::getAsString() const { return "list<" + Ty->getAsString() + ">"; } -Init *ListRecTy::convertValue(ListInit *LI) { - std::vector<Init*> Elements; +const Init *ListRecTy::convertValue(const ListInit *LI) { + std::vector<const 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 (Init *CI = LI->getElement(i)->convertInitializerTo(Ty)) + if (const Init *CI = LI->getElement(i)->convertInitializerTo(Ty)) Elements.push_back(CI); else return 0; @@ -303,7 +303,7 @@ Init *ListRecTy::convertValue(ListInit *LI) { return new ListInit(Elements, this); } -Init *ListRecTy::convertValue(TypedInit *TI) { +const Init *ListRecTy::convertValue(const TypedInit *TI) { // Ensure that TI is compatible with our class. if (ListRecTy *LRT = dynamic_cast<ListRecTy*>(TI->getType())) if (LRT->getElementType()->typeIsConvertibleTo(getElementType())) @@ -311,21 +311,21 @@ Init *ListRecTy::convertValue(TypedInit *TI) { return 0; } -Init *CodeRecTy::convertValue(TypedInit *TI) { +const Init *CodeRecTy::convertValue(const TypedInit *TI) { if (TI->getType()->typeIsConvertibleTo(this)) return TI; return 0; } -Init *DagRecTy::convertValue(TypedInit *TI) { +const Init *DagRecTy::convertValue(const TypedInit *TI) { if (TI->getType()->typeIsConvertibleTo(this)) return TI; return 0; } -Init *DagRecTy::convertValue(UnOpInit *BO) { +const Init *DagRecTy::convertValue(const UnOpInit *BO) { if (BO->getOpcode() == UnOpInit::CAST) { - Init *L = BO->getOperand()->convertInitializerTo(this); + const Init *L = BO->getOperand()->convertInitializerTo(this); if (L == 0) return 0; if (L != BO->getOperand()) return new UnOpInit(UnOpInit::CAST, L, new DagRecTy); @@ -334,10 +334,10 @@ Init *DagRecTy::convertValue(UnOpInit *BO) { return 0; } -Init *DagRecTy::convertValue(BinOpInit *BO) { +const Init *DagRecTy::convertValue(const BinOpInit *BO) { if (BO->getOpcode() == BinOpInit::CONCAT) { - Init *L = BO->getLHS()->convertInitializerTo(this); - Init *R = BO->getRHS()->convertInitializerTo(this); + const Init *L = BO->getLHS()->convertInitializerTo(this); + const Init *R = BO->getRHS()->convertInitializerTo(this); if (L == 0 || R == 0) return 0; if (L != BO->getLHS() || R != BO->getRHS()) return new BinOpInit(BinOpInit::CONCAT, L, R, new DagRecTy); @@ -354,14 +354,14 @@ std::string RecordRecTy::getAsString() const { return Rec->getName(); } -Init *RecordRecTy::convertValue(DefInit *DI) { +const Init *RecordRecTy::convertValue(const DefInit *DI) { // Ensure that DI is a subclass of Rec. if (!DI->getDef()->isSubClassOf(Rec)) return 0; return DI; } -Init *RecordRecTy::convertValue(TypedInit *TI) { +const Init *RecordRecTy::convertValue(const TypedInit *TI) { // Ensure that TI is compatible with Rec. if (RecordRecTy *RRT = dynamic_cast<RecordRecTy*>(TI->getType())) if (RRT->getRecord()->isSubClassOf(getRecord()) || @@ -442,22 +442,23 @@ RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) { void Init::dump() const { return print(errs()); } -Init *BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) { - SmallVector<Init *, 16> NewBits(Bits.size()); +const Init * +BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { + SmallVector<const Init *, 16> NewBits(Bits.size()); for (unsigned i = 0, e = Bits.size(); i != e; ++i) { if (Bits[i] >= getNumBits()) return 0; NewBits[i] = getBit(Bits[i]); } - return new BitsInit(ArrayRef<Init *>(NewBits)); + return new BitsInit(ArrayRef<const Init *>(NewBits)); } std::string BitsInit::getAsString() const { std::string Result = "{ "; for (unsigned i = 0, e = getNumBits(); i != e; ++i) { if (i) Result += ", "; - if (Init *Bit = getBit(e-i-1)) + if (const Init *Bit = getBit(e-i-1)) Result += Bit->getAsString(); else Result += "*"; @@ -468,13 +469,13 @@ std::string BitsInit::getAsString() const { // resolveReferences - If there are any field references that refer to fields // that have been filled in, we can propagate the values now. // -Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) { +const Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) const { bool Changed = false; - SmallVector<Init *, 16> NewBits(getNumBits()); + SmallVector<const Init *, 16> NewBits(getNumBits()); for (unsigned i = 0, e = Bits.size(); i != e; ++i) { - Init *B; - Init *CurBit = getBit(i); + const Init *B; + const Init *CurBit = getBit(i); do { B = CurBit; @@ -485,7 +486,7 @@ Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) { } if (Changed) - return new BitsInit(ArrayRef<Init *>(NewBits)); + return new BitsInit(ArrayRef<const Init *>(NewBits)); return this; } @@ -494,8 +495,9 @@ std::string IntInit::getAsString() const { return itostr(Value); } -Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) { - SmallVector<Init *, 16> NewBits(Bits.size()); +const Init * +IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const { + SmallVector<const Init *, 16> NewBits(Bits.size()); for (unsigned i = 0, e = Bits.size(); i != e; ++i) { if (Bits[i] >= 64) @@ -503,11 +505,12 @@ Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) { NewBits[i] = new BitInit(Value & (INT64_C(1) << Bits[i])); } - return new BitsInit(ArrayRef<Init *>(NewBits)); + return new BitsInit(ArrayRef<const Init *>(NewBits)); } -Init *ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) { - std::vector<Init*> Vals; +const Init * +ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const { + std::vector<const Init*> Vals; for (unsigned i = 0, e = Elements.size(); i != e; ++i) { if (Elements[i] >= getSize()) return 0; @@ -518,19 +521,19 @@ Init *ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) { Record *ListInit::getElementAsRecord(unsigned i) const { assert(i < Values.size() && "List element index out of range!"); - DefInit *DI = dynamic_cast<DefInit*>(Values[i]); + const DefInit *DI = dynamic_cast<const DefInit*>(Values[i]); if (DI == 0) throw "Expected record in list!"; return DI->getDef(); } -Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) { - std::vector<Init*> Resolved; +const Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) const { + std::vector<const Init*> Resolved; Resolved.reserve(getSize()); bool Changed = false; for (unsigned i = 0, e = getSize(); i != e; ++i) { - Init *E; - Init *CurElt = getElement(i); + const Init *E; + const Init *CurElt = getElement(i); do { E = CurElt; @@ -545,15 +548,16 @@ Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) { return this; } -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. - Init *E = getElement(Elt); + const 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<UnsetInit*>(E)) + if (IRV || !dynamic_cast<const UnsetInit*>(E)) return E; return 0; } @@ -567,12 +571,12 @@ std::string ListInit::getAsString() const { return Result + "]"; } -Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV, - unsigned Bit) { - Init *Folded = Fold(&R, 0); +const Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV, + unsigned Bit) const { + const Init *Folded = Fold(&R, 0); if (Folded != this) { - TypedInit *Typed = dynamic_cast<TypedInit *>(Folded); + const TypedInit *Typed = dynamic_cast<const TypedInit *>(Folded); if (Typed) { return Typed->resolveBitReference(R, IRV, Bit); } @@ -581,12 +585,12 @@ Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV, return 0; } -Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV, - unsigned Elt) { - Init *Folded = Fold(&R, 0); +const Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV, + unsigned Elt) const { + const Init *Folded = Fold(&R, 0); if (Folded != this) { - TypedInit *Typed = dynamic_cast<TypedInit *>(Folded); + const TypedInit *Typed = dynamic_cast<const TypedInit *>(Folded); if (Typed) { return Typed->resolveListElementReference(R, IRV, Elt); } @@ -595,22 +599,22 @@ Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV, return 0; } -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") { - StringInit *LHSs = dynamic_cast<StringInit*>(LHS); + const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS); if (LHSs) { return LHSs; } - DefInit *LHSd = dynamic_cast<DefInit*>(LHS); + const DefInit *LHSd = dynamic_cast<const DefInit*>(LHS); if (LHSd) { return new StringInit(LHSd->getDef()->getName()); } } else { - StringInit *LHSs = dynamic_cast<StringInit*>(LHS); + const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS); if (LHSs) { std::string Name = LHSs->getValue(); @@ -656,7 +660,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) { break; } case HEAD: { - ListInit *LHSl = dynamic_cast<ListInit*>(LHS); + const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS); if (LHSl) { if (LHSl->getSize() == 0) { assert(0 && "Empty list in car"); @@ -667,7 +671,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) { break; } case TAIL: { - ListInit *LHSl = dynamic_cast<ListInit*>(LHS); + const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS); if (LHSl) { if (LHSl->getSize() == 0) { assert(0 && "Empty list in cdr"); @@ -679,14 +683,15 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) { // they are not convertible to Init **. Fortunately, // RandomAccessIterator::operator * is guaranteed to return an // lvalue. - ListInit *Result = new ListInit(ArrayRef<Init *>(&*begin, end - begin), - LHSl->getType()); + ListInit *Result = + new ListInit(ArrayRef<const Init *>(&*begin, end - begin), + LHSl->getType()); return Result; } break; } case EMPTY: { - ListInit *LHSl = dynamic_cast<ListInit*>(LHS); + const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS); if (LHSl) { if (LHSl->getSize() == 0) { return new IntInit(1); @@ -694,7 +699,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) { return new IntInit(0); } } - StringInit *LHSs = dynamic_cast<StringInit*>(LHS); + const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS); if (LHSs) { if (LHSs->getValue().empty()) { return new IntInit(1); @@ -709,8 +714,8 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) { return this; } -Init *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) { - Init *lhs = LHS->resolveReferences(R, RV); +const Init *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) const { + const Init *lhs = LHS->resolveReferences(R, RV); if (LHS != lhs) return (new UnOpInit(getOpcode(), lhs, getType()))->Fold(&R, 0); @@ -728,18 +733,18 @@ std::string UnOpInit::getAsString() const { return Result + "(" + LHS->getAsString() + ")"; } -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: { - DagInit *LHSs = dynamic_cast<DagInit*>(LHS); - DagInit *RHSs = dynamic_cast<DagInit*>(RHS); + const DagInit *LHSs = dynamic_cast<const DagInit*>(LHS); + const DagInit *RHSs = dynamic_cast<const DagInit*>(RHS); if (LHSs && RHSs) { - DefInit *LOp = dynamic_cast<DefInit*>(LHSs->getOperator()); - DefInit *ROp = dynamic_cast<DefInit*>(RHSs->getOperator()); + const DefInit *LOp = dynamic_cast<const DefInit*>(LHSs->getOperator()); + const DefInit *ROp = dynamic_cast<const DefInit*>(RHSs->getOperator()); if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef()) throw "Concated Dag operators do not match!"; - std::vector<Init*> Args; + std::vector<const Init*> Args; std::vector<std::string> ArgNames; for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) { Args.push_back(LHSs->getArg(i)); @@ -754,8 +759,8 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) { break; } case STRCONCAT: { - StringInit *LHSs = dynamic_cast<StringInit*>(LHS); - StringInit *RHSs = dynamic_cast<StringInit*>(RHS); + const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS); + const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS); if (LHSs && RHSs) return new StringInit(LHSs->getValue() + RHSs->getValue()); break; @@ -763,16 +768,16 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) { case EQ: { // try to fold eq comparison for 'bit' and 'int', otherwise fallback // to string objects. - IntInit* L = - dynamic_cast<IntInit*>(LHS->convertInitializerTo(IntRecTy::get())); - IntInit* R = - dynamic_cast<IntInit*>(RHS->convertInitializerTo(IntRecTy::get())); + const IntInit* L = + dynamic_cast<const IntInit*>(LHS->convertInitializerTo(IntRecTy::get())); + const IntInit* R = + dynamic_cast<const IntInit*>(RHS->convertInitializerTo(IntRecTy::get())); if (L && R) return new IntInit(L->getValue() == R->getValue()); - StringInit *LHSs = dynamic_cast<StringInit*>(LHS); - StringInit *RHSs = dynamic_cast<StringInit*>(RHS); + const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS); + const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS); // Make sure we've resolved if (LHSs && RHSs) @@ -783,8 +788,8 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) { case SHL: case SRA: case SRL: { - IntInit *LHSi = dynamic_cast<IntInit*>(LHS); - IntInit *RHSi = dynamic_cast<IntInit*>(RHS); + const IntInit *LHSi = dynamic_cast<const IntInit*>(LHS); + const IntInit *RHSi = dynamic_cast<const IntInit*>(RHS); if (LHSi && RHSi) { int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue(); int64_t Result; @@ -802,9 +807,9 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) { return this; } -Init *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) { - Init *lhs = LHS->resolveReferences(R, RV); - Init *rhs = RHS->resolveReferences(R, RV); +const Init *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) const { + const Init *lhs = LHS->resolveReferences(R, RV); + const Init *rhs = RHS->resolveReferences(R, RV); if (LHS != lhs || RHS != rhs) return (new BinOpInit(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0); @@ -824,19 +829,21 @@ std::string BinOpInit::getAsString() const { return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")"; } -static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, - Record *CurRec, MultiClass *CurMultiClass); +static const Init *ForeachHelper(const Init *LHS, const Init *MHS, + const Init *RHS, RecTy *Type, + Record *CurRec, MultiClass *CurMultiClass); -static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, - RecTy *Type, Record *CurRec, - MultiClass *CurMultiClass) { - std::vector<Init *> NewOperands; +static const Init *EvaluateOperation(const OpInit *RHSo, const Init *LHS, + const Init *Arg, + RecTy *Type, Record *CurRec, + MultiClass *CurMultiClass) { + std::vector<const Init *> NewOperands; - TypedInit *TArg = dynamic_cast<TypedInit*>(Arg); + const TypedInit *TArg = dynamic_cast<const TypedInit*>(Arg); // If this is a dag, recurse if (TArg && TArg->getType()->getAsString() == "dag") { - Init *Result = ForeachHelper(LHS, Arg, RHSo, Type, + const Init *Result = ForeachHelper(LHS, Arg, RHSo, Type, CurRec, CurMultiClass); if (Result != 0) { return Result; @@ -846,10 +853,10 @@ static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, } for (int i = 0; i < RHSo->getNumOperands(); ++i) { - OpInit *RHSoo = dynamic_cast<OpInit*>(RHSo->getOperand(i)); + const OpInit *RHSoo = dynamic_cast<const OpInit*>(RHSo->getOperand(i)); if (RHSoo) { - Init *Result = EvaluateOperation(RHSoo, LHS, Arg, + const Init *Result = EvaluateOperation(RHSoo, LHS, Arg, Type, CurRec, CurMultiClass); if (Result != 0) { NewOperands.push_back(Result); @@ -864,8 +871,8 @@ static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, } // Now run the operator and use its result as the new leaf - OpInit *NewOp = RHSo->clone(NewOperands); - Init *NewVal = NewOp->Fold(CurRec, CurMultiClass); + const OpInit *NewOp = RHSo->clone(NewOperands); + const Init *NewVal = NewOp->Fold(CurRec, CurMultiClass); if (NewVal != NewOp) { delete NewOp; return NewVal; @@ -873,21 +880,23 @@ static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg, return 0; } -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); +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); DagRecTy *DagType = dynamic_cast<DagRecTy*>(Type); ListRecTy *ListType = dynamic_cast<ListRecTy*>(Type); - OpInit *RHSo = dynamic_cast<OpInit*>(RHS); + const OpInit *RHSo = dynamic_cast<const OpInit*>(RHS); if (!RHSo) { throw TGError(CurRec->getLoc(), "!foreach requires an operator\n"); } - TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS); + const TypedInit *LHSt = dynamic_cast<const TypedInit*>(LHS); if (!LHSt) { throw TGError(CurRec->getLoc(), "!foreach requires typed variable\n"); @@ -895,22 +904,22 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, if ((MHSd && DagType) || (MHSl && ListType)) { if (MHSd) { - Init *Val = MHSd->getOperator(); - Init *Result = EvaluateOperation(RHSo, LHS, Val, + const Init *Val = MHSd->getOperator(); + const Init *Result = EvaluateOperation(RHSo, LHS, Val, Type, CurRec, CurMultiClass); if (Result != 0) { Val = Result; } - std::vector<std::pair<Init *, std::string> > args; + std::vector<std::pair<const Init *, std::string> > args; for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) { - Init *Arg; + const Init *Arg; std::string ArgName; Arg = MHSd->getArg(i); ArgName = MHSd->getArgName(i); // Process args - Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type, + const Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type, CurRec, CurMultiClass); if (Result != 0) { Arg = Result; @@ -923,14 +932,14 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, return new DagInit(Val, "", args); } if (MHSl) { - std::vector<Init *> NewOperands; - std::vector<Init *> NewList(MHSl->begin(), MHSl->end()); + std::vector<const Init *> NewOperands; + std::vector<const Init *> NewList(MHSl->begin(), MHSl->end()); - for (std::vector<Init *>::iterator li = NewList.begin(), + for (std::vector<const Init *>::iterator li = NewList.begin(), liend = NewList.end(); li != liend; ++li) { - Init *Item = *li; + const Init *Item = *li; NewOperands.clear(); for(int i = 0; i < RHSo->getNumOperands(); ++i) { // First, replace the foreach variable with the list item @@ -942,8 +951,8 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, } // Now run the operator and use its result as the new list item - OpInit *NewOp = RHSo->clone(NewOperands); - Init *NewItem = NewOp->Fold(CurRec, CurMultiClass); + const OpInit *NewOp = RHSo->clone(NewOperands); + const Init *NewItem = NewOp->Fold(CurRec, CurMultiClass); if (NewItem != NewOp) { *li = NewItem; delete NewOp; @@ -955,21 +964,21 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, return 0; } -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: { - DefInit *LHSd = dynamic_cast<DefInit*>(LHS); - VarInit *LHSv = dynamic_cast<VarInit*>(LHS); - StringInit *LHSs = dynamic_cast<StringInit*>(LHS); + const DefInit *LHSd = dynamic_cast<const DefInit*>(LHS); + const VarInit *LHSv = dynamic_cast<const VarInit*>(LHS); + const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS); - DefInit *MHSd = dynamic_cast<DefInit*>(MHS); - VarInit *MHSv = dynamic_cast<VarInit*>(MHS); - StringInit *MHSs = dynamic_cast<StringInit*>(MHS); + const DefInit *MHSd = dynamic_cast<const DefInit*>(MHS); + const VarInit *MHSv = dynamic_cast<const VarInit*>(MHS); + const StringInit *MHSs = dynamic_cast<const StringInit*>(MHS); - DefInit *RHSd = dynamic_cast<DefInit*>(RHS); - VarInit *RHSv = dynamic_cast<VarInit*>(RHS); - StringInit *RHSs = dynamic_cast<StringInit*>(RHS); + const DefInit *RHSd = dynamic_cast<const DefInit*>(RHS); + const VarInit *RHSv = dynamic_cast<const VarInit*>(RHS); + const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS); if ((LHSd && MHSd && RHSd) || (LHSv && MHSv && RHSv) @@ -1008,7 +1017,7 @@ Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) { } case FOREACH: { - Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), + const Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), CurRec, CurMultiClass); if (Result != 0) { return Result; @@ -1017,9 +1026,9 @@ Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) { } case IF: { - IntInit *LHSi = dynamic_cast<IntInit*>(LHS); - if (Init *I = LHS->convertInitializerTo(IntRecTy::get())) - LHSi = dynamic_cast<IntInit*>(I); + const IntInit *LHSi = dynamic_cast<const IntInit*>(LHS); + if (const Init *I = LHS->convertInitializerTo(IntRecTy::get())) + LHSi = dynamic_cast<const IntInit*>(I); if (LHSi) { if (LHSi->getValue()) { return MHS; @@ -1034,29 +1043,30 @@ Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) { return this; } -Init *TernOpInit::resolveReferences(Record &R, const RecordVal *RV) { - Init *lhs = LHS->resolveReferences(R, RV); +const Init *TernOpInit::resolveReferences(Record &R, + const RecordVal *RV) const { + const Init *lhs = LHS->resolveReferences(R, RV); if (Opc == IF && lhs != LHS) { - IntInit *Value = dynamic_cast<IntInit*>(lhs); - if (Init *I = lhs->convertInitializerTo(IntRecTy::get())) - Value = dynamic_cast<IntInit*>(I); + const IntInit *Value = dynamic_cast<const IntInit*>(lhs); + if (const Init *I = lhs->convertInitializerTo(IntRecTy::get())) + Value = dynamic_cast<const IntInit*>(I); if (Value != 0) { // Short-circuit if (Value->getValue()) { - Init *mhs = MHS->resolveReferences(R, RV); + const Init *mhs = MHS->resolveReferences(R, RV); return (new TernOpInit(getOpcode(), lhs, mhs, RHS, getType()))->Fold(&R, 0); } else { - Init *rhs = RHS->resolveReferences(R, RV); + const Init *rhs = RHS->resolveReferences(R, RV); return (new TernOpInit(getOpcode(), lhs, MHS, rhs, getType()))->Fold(&R, 0); } } } - Init *mhs = MHS->resolveReferences(R, RV); - Init *rhs = RHS->resolveReferences(R, RV); + const Init *mhs = MHS->resolveReferences(R, RV); + const Init *rhs = RHS->resolveReferences(R, RV); if (LHS != lhs || MHS != mhs || RHS != rhs) return (new TernOpInit(getOpcode(), lhs, mhs, rhs, getType()))->Fold(&R, 0); @@ -1085,29 +1095,31 @@ RecTy *TypedInit::getFieldType(const std::string &FieldName) const { return 0; } -Init *TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) { +const 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<Init *, 16> NewBits(Bits.size()); + SmallVector<const Init *, 16> NewBits(Bits.size()); for (unsigned i = 0, e = Bits.size(); i != e; ++i) { if (Bits[i] >= NumBits) return 0; NewBits[i] = new VarBitInit(this, Bits[i]); } - return new BitsInit(ArrayRef<Init *>(NewBits)); + return new BitsInit(ArrayRef<const Init *>(NewBits)); } -Init *TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) { +const 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 new VarListElementInit(this, Elements[0]); - std::vector<Init*> ListInits; + std::vector<const Init*> ListInits; ListInits.reserve(Elements.size()); for (unsigned i = 0, e = Elements.size(); i != e; ++i) ListInits.push_back(new VarListElementInit(this, Elements[i])); @@ -1115,48 +1127,49 @@ Init *TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) { } -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<BitsInit*>(RV->getValue())); - BitsInit *BI = (BitsInit*)RV->getValue(); + assert(dynamic_cast<const BitsInit*>(RV->getValue())); + const BitsInit *BI = (const BitsInit*)RV->getValue(); assert(Bit < BI->getNumBits() && "Bit reference out of range!"); - Init *B = BI->getBit(Bit); + const 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<UnsetInit*>(B)) + if (IRV || !dynamic_cast<const UnsetInit*>(B)) return B; return 0; } -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?"); - ListInit *LI = dynamic_cast<ListInit*>(RV->getValue()); + const ListInit *LI = dynamic_cast<const ListInit*>(RV->getValue()); if (!LI) { - VarInit *VI = dynamic_cast<VarInit*>(RV->getValue()); + const VarInit *VI = dynamic_cast<const VarInit*>(RV->getValue()); assert(VI && "Invalid list element!"); return new VarListElementInit(VI, Elt); } if (Elt >= LI->getSize()) return 0; // Out of range reference. - Init *E = LI->getElement(Elt); + const 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<UnsetInit*>(E)) + if (IRV || !dynamic_cast<const UnsetInit*>(E)) return E; return 0; } @@ -1169,15 +1182,15 @@ RecTy *VarInit::getFieldType(const std::string &FieldName) const { return 0; } -Init *VarInit::getFieldInit(Record &R, const RecordVal *RV, - const std::string &FieldName) const { +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<UnsetInit*>(Val->getValue()))) + if (RV != Val && (RV || dynamic_cast<const UnsetInit*>(Val->getValue()))) return 0; - Init *TheInit = Val->getValue(); + const Init *TheInit = Val->getValue(); assert(TheInit != this && "Infinite loop detected!"); - if (Init *I = TheInit->getFieldInit(R, RV, FieldName)) + if (const Init *I = TheInit->getFieldInit(R, RV, FieldName)) return I; else return 0; @@ -1190,9 +1203,9 @@ Init *VarInit::getFieldInit(Record &R, const RecordVal *RV, /// If a value is set for the variable later, this method will be called on /// users of the value to allow the value to propagate out. /// -Init *VarInit::resolveReferences(Record &R, 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<UnsetInit*>(Val->getValue()))) + if (RV == Val || (RV == 0 && !dynamic_cast<const UnsetInit*>(Val->getValue()))) return Val->getValue(); return this; } @@ -1201,8 +1214,9 @@ std::string VarBitInit::getAsString() const { return TI->getAsString() + "{" + utostr(Bit) + "}"; } -Init *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) { - if (Init *I = getVariable()->resolveBitReference(R, RV, getBitNum())) +const Init *VarBitInit::resolveReferences(Record &R, + const RecordVal *RV) const { + if (const Init *I = getVariable()->resolveBitReference(R, RV, getBitNum())) return I; return this; } @@ -1211,22 +1225,25 @@ std::string VarListElementInit::getAsString() const { return TI->getAsString() + "[" + utostr(Element) + "]"; } -Init *VarListElementInit::resolveReferences(Record &R, const RecordVal *RV) { - if (Init *I = getVariable()->resolveListElementReference(R, RV, +const Init *VarListElementInit::resolveReferences(Record &R, + const RecordVal *RV) const { + if (const Init *I = getVariable()->resolveListElementReference(R, RV, getElementNum())) return I; return this; } -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; } -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; @@ -1242,8 +1259,8 @@ RecTy *DefInit::getFieldType(const std::string &FieldName) const { return 0; } -Init *DefInit::getFieldInit(Record &R, const RecordVal *RV, - const std::string &FieldName) const { +const Init *DefInit::getFieldInit(Record &R, const RecordVal *RV, + const std::string &FieldName) const { return Def->getValue(FieldName)->getValue(); } @@ -1252,41 +1269,42 @@ std::string DefInit::getAsString() const { return Def->getName(); } -Init *FieldInit::resolveBitReference(Record &R, const RecordVal *RV, - unsigned Bit) { - if (Init *BitsVal = Rec->getFieldInit(R, RV, FieldName)) - if (BitsInit *BI = dynamic_cast<BitsInit*>(BitsVal)) { +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)) { assert(Bit < BI->getNumBits() && "Bit reference out of range!"); - Init *B = BI->getBit(Bit); + const Init *B = BI->getBit(Bit); - if (dynamic_cast<BitInit*>(B)) // If the bit is set. + if (dynamic_cast<const BitInit*>(B)) // If the bit is set. return B; // Replace the VarBitInit with it. } return 0; } -Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt) { - if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName)) - if (ListInit *LI = dynamic_cast<ListInit*>(ListVal)) { +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)) { if (Elt >= LI->getSize()) return 0; - Init *E = LI->getElement(Elt); + const 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<UnsetInit*>(E)) + if (RV || !dynamic_cast<const UnsetInit*>(E)) return E; } return 0; } -Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) { - Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec; +const Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const { + const Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec; - Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName); + const Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName); if (BitsVal) { - Init *BVR = BitsVal->resolveReferences(R, RV); + const Init *BVR = BitsVal->resolveReferences(R, RV); return BVR->isComplete() ? BVR : this; } @@ -1296,12 +1314,12 @@ Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) { return this; } -Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) { - std::vector<Init*> NewArgs; +const Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) const { + std::vector<const Init*> NewArgs; for (unsigned i = 0, e = Args.size(); i != e; ++i) NewArgs.push_back(Args[i]->resolveReferences(R, RV)); - Init *Op = Val->resolveReferences(R, RV); + const Init *Op = Val->resolveReferences(R, RV); if (Args != NewArgs || Op != Val) return new DagInit(Op, ValName, NewArgs, ArgNames); @@ -1373,7 +1391,7 @@ void Record::setName(const std::string &Name) { /// references. void Record::resolveReferencesTo(const RecordVal *RV) { for (unsigned i = 0, e = Values.size(); i != e; ++i) { - if (Init *V = Values[i].getValue()) + if (const Init *V = Values[i].getValue()) Values[i].setValue(V->resolveReferences(*this, RV)); } } @@ -1418,7 +1436,7 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) { /// getValueInit - Return the initializer for a value with the specified name, /// or throw an exception if the field does not exist. /// -Init *Record::getValueInit(StringRef FieldName) const { +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 `" + @@ -1447,13 +1465,13 @@ std::string Record::getValueAsString(StringRef FieldName) const { /// its value as a BitsInit, throwing an exception if the field does not exist /// or if the value is not the right type. /// -BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const { +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 (BitsInit *BI = dynamic_cast<BitsInit*>(R->getValue())) + if (const BitsInit *BI = dynamic_cast<const BitsInit*>(R->getValue())) return BI; throw "Record `" + getName() + "', field `" + FieldName.str() + "' does not have a BitsInit initializer!"; @@ -1463,13 +1481,13 @@ BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const { /// its value as a ListInit, throwing an exception if the field does not exist /// or if the value is not the right type. /// -ListInit *Record::getValueAsListInit(StringRef FieldName) const { +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 (ListInit *LI = dynamic_cast<ListInit*>(R->getValue())) + if (const ListInit *LI = dynamic_cast<const ListInit*>(R->getValue())) return LI; throw "Record `" + getName() + "', field `" + FieldName.str() + "' does not have a list initializer!"; @@ -1481,10 +1499,10 @@ ListInit *Record::getValueAsListInit(StringRef FieldName) const { /// std::vector<Record*> Record::getValueAsListOfDefs(StringRef FieldName) const { - ListInit *List = getValueAsListInit(FieldName); + const ListInit *List = getValueAsListInit(FieldName); std::vector<Record*> Defs; for (unsigned i = 0; i < List->getSize(); i++) { - if (DefInit *DI = dynamic_cast<DefInit*>(List->getElement(i))) { + if (const DefInit *DI = dynamic_cast<const DefInit*>(List->getElement(i))) { Defs.push_back(DI->getDef()); } else { throw "Record `" + getName() + "', field `" + FieldName.str() + @@ -1504,7 +1522,7 @@ int64_t Record::getValueAsInt(StringRef FieldName) const { throw "Record `" + getName() + "' does not have a field named `" + FieldName.str() + "'!\n"; - if (IntInit *II = dynamic_cast<IntInit*>(R->getValue())) + if (const IntInit *II = dynamic_cast<const IntInit*>(R->getValue())) return II->getValue(); throw "Record `" + getName() + "', field `" + FieldName.str() + "' does not have an int initializer!"; @@ -1516,10 +1534,10 @@ int64_t Record::getValueAsInt(StringRef FieldName) const { /// std::vector<int64_t> Record::getValueAsListOfInts(StringRef FieldName) const { - ListInit *List = getValueAsListInit(FieldName); + const ListInit *List = getValueAsListInit(FieldName); std::vector<int64_t> Ints; for (unsigned i = 0; i < List->getSize(); i++) { - if (IntInit *II = dynamic_cast<IntInit*>(List->getElement(i))) { + if (const IntInit *II = dynamic_cast<const IntInit*>(List->getElement(i))) { Ints.push_back(II->getValue()); } else { throw "Record `" + getName() + "', field `" + FieldName.str() + @@ -1535,10 +1553,10 @@ Record::getValueAsListOfInts(StringRef FieldName) const { /// std::vector<std::string> Record::getValueAsListOfStrings(StringRef FieldName) const { - ListInit *List = getValueAsListInit(FieldName); + const ListInit *List = getValueAsListInit(FieldName); std::vector<std::string> Strings; for (unsigned i = 0; i < List->getSize(); i++) { - if (StringInit *II = dynamic_cast<StringInit*>(List->getElement(i))) { + if (const StringInit *II = dynamic_cast<const StringInit*>(List->getElement(i))) { Strings.push_back(II->getValue()); } else { throw "Record `" + getName() + "', field `" + FieldName.str() + @@ -1558,7 +1576,7 @@ Record *Record::getValueAsDef(StringRef FieldName) const { throw "Record `" + getName() + "' does not have a field named `" + FieldName.str() + "'!\n"; - if (DefInit *DI = dynamic_cast<DefInit*>(R->getValue())) + if (const DefInit *DI = dynamic_cast<const DefInit*>(R->getValue())) return DI->getDef(); throw "Record `" + getName() + "', field `" + FieldName.str() + "' does not have a def initializer!"; @@ -1574,7 +1592,7 @@ bool Record::getValueAsBit(StringRef FieldName) const { throw "Record `" + getName() + "' does not have a field named `" + FieldName.str() + "'!\n"; - if (BitInit *BI = dynamic_cast<BitInit*>(R->getValue())) + if (const BitInit *BI = dynamic_cast<const BitInit*>(R->getValue())) return BI->getValue(); throw "Record `" + getName() + "', field `" + FieldName.str() + "' does not have a bit initializer!"; @@ -1584,13 +1602,13 @@ bool Record::getValueAsBit(StringRef FieldName) const { /// value as an Dag, throwing an exception if the field does not exist or if /// the value is not the right type. /// -DagInit *Record::getValueAsDag(StringRef FieldName) const { +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 (DagInit *DI = dynamic_cast<DagInit*>(R->getValue())) + if (const DagInit *DI = dynamic_cast<const DagInit*>(R->getValue())) return DI; throw "Record `" + getName() + "', field `" + FieldName.str() + "' does not have a dag initializer!"; diff --git a/utils/TableGen/Record.h b/utils/TableGen/Record.h index 599b6dcd5c..c49a720edd 100644 --- a/utils/TableGen/Record.h +++ b/utils/TableGen/Record.h @@ -82,31 +82,31 @@ public: ListRecTy *getListTy(); public: // These methods should only be called from subclasses of Init - 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 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 Init *convertValue( BinOpInit *UI) { - return convertValue((TypedInit*)UI); + virtual const Init *convertValue( const BinOpInit *UI) { + return convertValue((const TypedInit*)UI); } - virtual Init *convertValue( TernOpInit *UI) { - return convertValue((TypedInit*)UI); + virtual const Init *convertValue( const TernOpInit *UI) { + return convertValue((const 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 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( FieldInit *FI) { - return convertValue((TypedInit*)FI); + virtual const Init *convertValue( const FieldInit *FI) { + return convertValue((const TypedInit*)FI); } public: // These methods should only be called by subclasses of RecTy. @@ -136,22 +136,22 @@ class BitRecTy : public RecTy { public: static BitRecTy *get() { return &Shared; } - 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);} + 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);} std::string getAsString() const { return "bit"; } @@ -181,22 +181,22 @@ public: unsigned getNumBits() const { return Size; } - 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);} + 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);} std::string getAsString() const; @@ -225,22 +225,22 @@ class IntRecTy : public RecTy { public: static IntRecTy *get() { return &Shared; } - 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);} + 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);} std::string getAsString() const { return "int"; } @@ -267,23 +267,23 @@ class StringRecTy : public RecTy { public: static StringRecTy *get() { return &Shared; } - 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);} + 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);} std::string getAsString() const { return "string"; } @@ -314,22 +314,22 @@ public: static ListRecTy *get(RecTy *T) { return T->getListTy(); } RecTy *getElementType() const { return Ty; } - 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);} + 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);} std::string getAsString() const; @@ -357,22 +357,22 @@ class CodeRecTy : public RecTy { public: static CodeRecTy *get() { return &Shared; } - 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);} + 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);} std::string getAsString() const { return "code"; } @@ -397,22 +397,22 @@ class DagRecTy : public RecTy { public: static DagRecTy *get() { return &Shared; } - 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);} + 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);} std::string getAsString() const { return "dag"; } @@ -443,22 +443,22 @@ public: Record *getRecord() const { return Rec; } - 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);} + 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);} std::string getAsString() const; @@ -506,14 +506,15 @@ public: /// function that should be overridden to call the appropriate /// RecTy::convertValue method. /// - virtual Init *convertInitializerTo(RecTy *Ty) = 0; + virtual const 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 Init *convertInitializerBitRange(const std::vector<unsigned> &Bits) { + virtual const Init * + convertInitializerBitRange(const std::vector<unsigned> &Bits) const { return 0; } @@ -522,7 +523,8 @@ public: /// elements, returning them as a new init of list type. If it is not legal /// to take a slice of this, return null. /// - virtual Init *convertInitListSlice(const std::vector<unsigned> &Elements) { + virtual const Init * + convertInitListSlice(const std::vector<unsigned> &Elements) const { return 0; } @@ -536,8 +538,8 @@ public: /// initializer for the specified field. If getFieldType returns non-null /// this method should return non-null, otherwise it returns null. /// - virtual Init *getFieldInit(Record &R, const RecordVal *RV, - const std::string &FieldName) const { + virtual const Init *getFieldInit(Record &R, const RecordVal *RV, + const std::string &FieldName) const { return 0; } @@ -546,7 +548,7 @@ public: /// 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 Init *resolveReferences(Record &R, const RecordVal *RV) { + virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const { return this; } }; @@ -565,8 +567,10 @@ public: RecTy *getType() const { return Ty; } - virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits); - virtual Init *convertInitListSlice(const std::vector<unsigned> &Elements); + virtual const Init * + convertInitializerBitRange(const std::vector<unsigned> &Bits) const; + virtual const Init * + convertInitListSlice(const std::vector<unsigned> &Elements) const; /// getFieldType - This method is used to implement the FieldInit class. /// Implementors of this method should return the type of the named field if @@ -578,14 +582,14 @@ public: /// VarBitInit::resolveReferences. If the bit is able to be resolved, we /// simply return the resolved value, otherwise we return null. /// - virtual Init *resolveBitReference(Record &R, const RecordVal *RV, - unsigned Bit) = 0; + virtual const 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 Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt) = 0; + virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const = 0; }; @@ -593,7 +597,7 @@ public: /// class UnsetInit : public Init { public: - virtual Init *convertInitializerTo(RecTy *Ty) { + virtual const Init *convertInitializerTo(RecTy *Ty) const { return Ty->convertValue(this); } @@ -611,7 +615,7 @@ public: bool getValue() const { return Value; } - virtual Init *convertInitializerTo(RecTy *Ty) { + virtual const Init *convertInitializerTo(RecTy *Ty) const { return Ty->convertValue(this); } @@ -622,22 +626,23 @@ public: /// It contains a vector of bits, whose size is determined by the type. /// class BitsInit : public Init { - std::vector<Init*> Bits; + std::vector<const Init*> Bits; public: explicit BitsInit(unsigned Size) : Bits(Size) {} - BitsInit(ArrayRef<Init *> Range) : Bits(Range.begin(), Range.end()) {} + BitsInit(ArrayRef<const Init *> Range) : Bits(Range.begin(), Range.end()) {} unsigned getNumBits() const { return Bits.size(); } - Init *getBit(unsigned Bit) const { + const Init *getBit(unsigned Bit) const { assert(Bit < Bits.size() && "Bit index out of range!"); return Bits[Bit]; } - virtual Init *convertInitializerTo(RecTy *Ty) { + virtual const Init *convertInitializerTo(RecTy *Ty) const { return Ty->convertValue(this); } - virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits); + virtual const Init * + convertInitializerBitRange(const std::vector<unsigned> &Bits) const; virtual bool isComplete() const { for (unsigned i = 0; i != getNumBits(); ++i) @@ -651,7 +656,7 @@ public: } virtual std::string getAsString() const; - virtual Init *resolveReferences(Record &R, const RecordVal *RV); + virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const; }; @@ -664,10 +669,11 @@ public: int64_t getValue() const { return Value; } - virtual Init *convertInitializerTo(RecTy *Ty) { + virtual const Init *convertInitializerTo(RecTy *Ty) const { return Ty->convertValue(this); } - virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits); + virtual const Init * + convertInitializerBitRange(const std::vector<unsigned> &Bits) const; virtual std::string getAsString() const; @@ -675,8 +681,8 @@ public: /// VarBitInit::resolveReferences. If the bit is able to be resolved, we /// simply return the resolved value, otherwise we return null. /// - virtual Init *resolveBitReference(Record &R, const RecordVal *RV, - unsigned Bit) { + virtual const Init *resolveBitReference(Record &R, const RecordVal *RV, + unsigned Bit) const { assert(0 && "Illegal bit reference off int"); return 0; } @@ -684,8 +690,8 @@ public: /// 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 Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt) { + virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const { assert(0 && "Illegal element reference off int"); return 0; } @@ -702,7 +708,7 @@ public: const std::string &getValue() const { return Value; } - virtual Init *convertInitializerTo(RecTy *Ty) { + virtual const Init *convertInitializerTo(RecTy *Ty) const { return Ty->convertValue(this); } @@ -712,8 +718,8 @@ public: /// VarBitInit::resolveReferences. If the bit is able to be resolved, we /// simply return the resolved value, otherwise we return null. /// - virtual Init *resolveBitReference(Record &R, const RecordVal *RV, - unsigned Bit) { + virtual const Init *resolveBitReference(Record &R, const RecordVal *RV, + unsigned Bit) const { assert(0 && "Illegal bit reference off string"); return 0; } @@ -721,8 +727,8 @@ public: /// 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 Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt) { + virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const { assert(0 && "Illegal element reference off string"); return 0; } @@ -737,7 +743,7 @@ public: const std::string &getValue() const { return Value; } - virtual Init *convertInitializerTo(RecTy *Ty) { + virtual const Init *convertInitializerTo(RecTy *Ty) const { return Ty->convertValue(this); } @@ -747,28 +753,28 @@ public: /// ListInit - [AL, AH, CL] - Represent a list of defs /// class ListInit : public TypedInit { - std::vector<Init*> Values; + std::vector<const Init*> Values; public: - typedef std::vector<Init*>::const_iterator const_iterator; + typedef std::vector<const Init*>::const_iterator const_iterator; - explicit ListInit(std::vector<Init*> &Vs, RecTy *EltTy) + explicit ListInit(std::vector<const Init*> &Vs, RecTy *EltTy) : TypedInit(ListRecTy::get(EltTy)) { Values.swap(Vs); } - explicit ListInit(ArrayRef<Init *> Range, RecTy *EltTy) + explicit ListInit(ArrayRef<const Init *> Range, RecTy *EltTy) : TypedInit(ListRecTy::get(EltTy)), Values(Range.begin(), Range.end()) {} unsigned getSize() const { return Values.size(); } - Init *getElement(unsigned i) const { + const Init *getElement(unsigned i) const { assert(i < Values.size() && "List element index out of range!"); return Values[i]; } Record *getElementAsRecord(unsigned i) const; - Init *convertInitListSlice(const std::vector<unsigned> &Elements); + const Init *convertInitListSlice(const std::vector<unsigned> &Elements) const; - virtual Init *convertInitializerTo(RecTy *Ty) { + virtual const Init *convertInitializerTo(RecTy *Ty) const { return Ty->convertValue(this); } @@ -777,11 +783,11 @@ public: /// 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 Init *resolveReferences(Record &R, const RecordVal *RV); + virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const; virtual std::string getAsString() const; - ArrayRef<Init*> getValues() const { return Values; } + ArrayRef<const Init*> getValues() const { return Values; } inline const_iterator begin() const { return Values.begin(); } inline const_iterator end () const { return Values.end(); } @@ -793,8 +799,8 @@ public: /// VarBitInit::resolveReferences. If the bit is able to be resolved, we /// simply return the resolved value, otherwise we return null. /// - virtual Init *resolveBitReference(Record &R, const RecordVal *RV, - unsigned Bit) { + virtual const Init *resolveBitReference(Record &R, const RecordVal *RV, + unsigned Bit) const { assert(0 && "Illegal bit reference off list"); return 0; } @@ -802,8 +808,8 @@ public: /// 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 Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt); + virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const; }; @@ -814,23 +820,24 @@ public: OpInit(RecTy *Type) : TypedInit(Type) {} // Clone - Clone this operator, replacing arguments with the new list - virtual OpInit *clone(std::vector<Init *> &Operands) = 0; + virtual const OpInit *clone(std::vector<const Init *> &Operands) const = 0; virtual int getNumOperands() const = 0; - virtual Init *getOperand(int i) = 0; + virtual const Init *getOperand(int i) const = 0; // Fold - If possible, fold this to a simpler init. Return this if not // possible to fold. - virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) = 0; + virtual const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0; - virtual Init *convertInitializerTo(RecTy *Ty) { + virtual const Init *convertInitializerTo(RecTy *Ty) const { return Ty->convertValue(this); } - virtual Init *resolveBitReference(Record &R, const RecordVal *RV, - unsigned Bit); - virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt); + virtual const Init *resolveBitReference(Record &R, const RecordVal *RV, + unsigned Bit) const; + virtual const Init *resolveListElementReference(Record &R, + const RecordVal *RV, + unsigned Elt) const; }; @@ -841,33 +848,33 @@ public: enum UnaryOp { CAST, HEAD, TAIL, EMPTY }; private: UnaryOp Opc; - Init *LHS; + const Init *LHS; public: - UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type) : + UnOpInit(UnaryOp opc, const Init *lhs, RecTy *Type) : OpInit(Type), Opc(opc), LHS(lhs) { } // Clone - Clone this operator, replacing arguments with the new list - virtual OpInit *clone(std::vector<Init *> &Operands) { + virtual const OpInit *clone(std::vector<const Init *> &Operands) const { assert(Operands.size() == 1 && "Wrong number of operands for unary operation"); return new UnOpInit(getOpcode(), *Operands.begin(), getType()); } int getNumOperands() const { return 1; } - 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; } - Init *getOperand() const { return LHS; } + const Init *getOperand() const { return LHS; } // Fold - If possible, fold this to a simpler init. Return this if not // possible to fold. - Init *Fold(Record *CurRec, MultiClass *CurMultiClass); + const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const; - virtual Init *resolveReferences(Record &R, const RecordVal *RV); + virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const; virtual std::string getAsString() const; }; @@ -879,21 +886,21 @@ public: enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, EQ }; private: BinaryOp Opc; - Init *LHS, *RHS; + const Init *LHS, *RHS; public: - BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) : + BinOpInit(BinaryOp opc, const Init *lhs, const Init *rhs, RecTy *Type) : OpInit(Type), Opc(opc), LHS(lhs), RHS(rhs) { } // Clone - Clone this operator, replacing arguments with the new list - virtual OpInit *clone(std::vector<Init *> &Operands) { + virtual const OpInit *clone(std::vector<const Init *> &Operands) const { assert(Operands.size() == 2 && "Wrong number of operands for binary operation"); return new BinOpInit(getOpcode(), Operands[0], Operands[1], getType()); } int getNumOperands() const { return 2; } - 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(); @@ -903,14 +910,14 @@ public: } BinaryOp getOpcode() const { return Opc; } - Init *getLHS() const { return LHS; } - Init *getRHS() const { return RHS; } + const Init *getLHS() const { return LHS; } + const Init *getRHS() const { return RHS; } // Fold - If possible, fold this to a simpler init. Return this if not // possible to fold. - Init *Fold(Record *CurRec, MultiClass *CurMultiClass); + const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const; - virtual Init *resolveReferences(Record &R, const RecordVal *RV); + virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const; virtual std::string getAsString() const; }; @@ -922,14 +929,15 @@ public: enum TernaryOp { SUBST, FOREACH, IF }; private: TernaryOp Opc; - Init *LHS, *MHS, *RHS; + const Init *LHS, *MHS, *RHS; public: - TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs, RecTy *Type) : + TernOpInit(TernaryOp opc, const Init *lhs, const Init *mhs, const Init *rhs, + RecTy *Type) : OpInit(Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) { } // Clone - Clone this operator, replacing arguments with the new list - virtual OpInit *clone(std::vector<Init *> &Operands) { + virtual const OpInit *clone(std::vector<const Init *> &Operands) const { assert(Operands.size() == 3 && "Wrong number of operands for ternary operation"); return new TernOpInit(getOpcode(), Operands[0], Operands[1], Operands[2], @@ -937,7 +945,7 @@ public: } int getNumOperands() const { return 3; } - 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) { @@ -950,17 +958,17 @@ public: } TernaryOp getOpcode() const { return Opc; } - Init *getLHS() const { return LHS; } - Init *getMHS() const { return MHS; } - Init *getRHS() const { return RHS; } + const Init *getLHS() const { return LHS; } + const Init *getMHS() const { return MHS; } + const Init *getRHS() const { return RHS; } // Fold - If possible, fold this to a simpler init. Return this if not // possible to fold. - Init *Fold(Record *CurRec, MultiClass *CurMultiClass); + const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const; virtual bool isComplete() const { return false; } - virtual Init *resolveReferences(Record &R, const RecordVal *RV); + virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const; virtual std::string getAsString() const; }; @@ -974,27 +982,27 @@ public: explicit VarInit(const std::string &VN, RecTy *T) : TypedInit(T), VarName(VN) {} - virtual Init *convertInitializerTo(RecTy *Ty) { + virtual const Init *convertInitializerTo(RecTy *Ty) const { return Ty->convertValue(this); } const std::string &getName() const { return VarName; } - virtual Init *resolveBitReference(Record &R, const RecordVal *RV, - unsigned Bit); - virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt); + 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 RecTy *getFieldType(const std::string &FieldName) const; - virtual Init *getFieldInit(Record &R, const RecordVal *RV, - const std::string &FieldName) const; + virtual const 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 Init *resolveReferences(Record &R, const RecordVal *RV); + virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const; virtual std::string getAsString() const { return VarName; } }; @@ -1003,57 +1011,58 @@ public: /// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field. /// class VarBitInit : public Init { - TypedInit *TI; + const TypedInit *TI; unsigned Bit; public: - VarBitInit(TypedInit *T, unsigned B) : TI(T), Bit(B) { + VarBitInit(const TypedInit *T, unsigned B) : TI(T), Bit(B) { assert(T->getType() && dynamic_cast<BitsRecTy*>(T->getType()) && ((BitsRecTy*)T->getType())->getNumBits() > B && "Illegal VarBitInit expression!"); } - virtual Init *convertInitializerTo(RecTy *Ty) { + virtual const Init *convertInitializerTo(RecTy *Ty) const { return Ty->convertValue(this); } - TypedInit *getVariable() const { return TI; } + const TypedInit *getVariable() const { return TI; } unsigned getBitNum() const { return Bit; } virtual std::string getAsString() const; - virtual Init *resolveReferences(Record &R, const RecordVal *RV); + virtual const 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 { - TypedInit *TI; + const TypedInit *TI; unsigned Element; public: - VarListElementInit(TypedInit *T, unsigned E) + VarListElementInit(const TypedInit *T, unsigned E) : TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()), TI(T), Element(E) { assert(T->getType() && dynamic_cast<ListRecTy*>(T->getType()) && "Illegal VarBitInit expression!"); } - virtual Init *convertInitializerTo(RecTy *Ty) { + virtual const Init *convertInitializerTo(RecTy *Ty) const { return Ty->convertValue(this); } - TypedInit *getVariable() const { return TI; } + const TypedInit *getVariable() const { return TI; } unsigned getElementNum() const { return Element; } - virtual Init *resolveBitReference(Record &R, const RecordVal *RV, - unsigned Bit); + virtual const 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 Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt); + virtual const Init *resolveListElementReference(Record &R, + const RecordVal *RV, + unsigned Elt) const; virtual std::string getAsString() const; - virtual Init *resolveReferences(Record &R, const RecordVal *RV); + virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const; }; /// DefInit - AL - Represent a reference to a 'def' in the description @@ -1065,17 +1074,18 @@ class DefInit : public TypedInit { public: static DefInit *get(Record*); - virtual Init *convertInitializerTo(RecTy *Ty) { + virtual const Init *convertInitializerTo(RecTy *Ty) const { return Ty->convertValue(this); } Record *getDef() const { return Def; } - //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits); + //virtual const Init * + //convertInitializerBitRange(const std::vector<unsigned> &Bits); virtual RecTy *getFieldType(const std::string &FieldName) const; - virtual Init *getFieldInit(Record &R, const RecordVal *RV, - const std::string &FieldName) const; + virtual const Init *getFieldInit(Record &R, const RecordVal *RV, + const std::string &FieldName) const; virtual std::string getAsString() const; @@ -1083,8 +1093,8 @@ public: /// VarBitInit::resolveReferences. If the bit is able to be resolved, we /// simply return the resolved value, otherwise we return null. /// - virtual Init *resolveBitReference(Record &R, const RecordVal *RV, - unsigned Bit) { + virtual const Init *resolveBitReference(Record &R, const RecordVal *RV, + unsigned Bit) const { assert(0 && "Illegal bit reference off def"); return 0; } @@ -1092,8 +1102,8 @@ public: /// 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 Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt) { + virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV, + unsigned Elt) const { assert(0 && "Illegal element reference off def"); return 0; } @@ -1103,24 +1113,25 @@ public: /// FieldInit - X.Y - Represent a reference to a subfield of a variable /// class FieldInit : public TypedInit { - Init *Rec; // Record we are referring to + const Init *Rec; // Record we are referring to std::string FieldName; // Field we are accessing public: - FieldInit(Init *R, const std::string &FN) + FieldInit(const Init *R, const std::string &FN) : TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) { assert(getType() && "FieldInit with non-record type!"); } - virtual Init *convertInitializerTo(RecTy *Ty) { + virtual const Init *convertInitializerTo(RecTy *Ty) const { return Ty->convertValue(this); } - virtual Init *resolveBitReference(Record &R, const RecordVal *RV, - unsigned Bit); - virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt); + 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 *resolveReferences(Record &R, const RecordVal *RV); + virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const; virtual std::string getAsString() const { return Rec->getAsString() + "." + FieldName; @@ -1132,13 +1143,13 @@ public: /// argument can have a name associated with it. /// class DagInit : public TypedInit { - Init *Val; + const Init *Val; std::string ValName; - std::vector<Init*> Args; + std::vector<const Init*> Args; std::vector<std::string> ArgNames; public: - DagInit(Init *V, std::string VN, - const std::vector<std::pair<Init*, std::string> > &args) + DagInit(const Init *V, std::string VN, + const std::vector<std::pair<const Init*, std::string> > &args) : TypedInit(DagRecTy::get()), Val(V), ValName(VN) { Args.reserve(args.size()); ArgNames.reserve(args.size()); @@ -1147,21 +1158,21 @@ public: ArgNames.push_back(args[i].second); } } - DagInit(Init *V, std::string VN, const std::vector<Init*> &args, + DagInit(const Init *V, std::string VN, const std::vector<const Init*> &args, const std::vector<std::string> &argNames) : TypedInit(DagRecTy::get()), Val(V), ValName(VN), Args(args), ArgNames(argNames) { } - virtual Init *convertInitializerTo(RecTy *Ty) { + virtual const Init *convertInitializerTo(RecTy *Ty) const { return Ty->convertValue(this); } - Init *getOperator() const { return Val; } + const Init *getOperator() const { return Val; } const std::string &getName() const { return ValName; } unsigned getNumArgs() const { return Args.size(); } - Init *getArg(unsigned Num) const { + const Init *getArg(unsigned Num) const { assert(Num < Args.size() && "Arg number out of range!"); return Args[Num]; } @@ -1170,11 +1181,11 @@ public: return ArgNames[Num]; } - virtual Init *resolveReferences(Record &R, const RecordVal *RV); + virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const; virtual std::string getAsString() const; - typedef std::vector<Init*>::const_iterator const_arg_iterator; + typedef std::vector<const 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(); } @@ -1189,14 +1200,15 @@ public: inline size_t name_size () const { return ArgNames.size(); } inline bool name_empty() const { return ArgNames.empty(); } - virtual Init *resolveBitReference(Record &R, const RecordVal *RV, - unsigned Bit) { + virtual const Init *resolveBitReference(Record &R, const RecordVal *RV, + unsigned Bit) const { assert(0 && "Illegal bit reference off dag"); return 0; } - virtual Init *resolveListElementReference(Record &R, const RecordVal *RV, - unsigned Elt) { + virtual const Init *resolveListElementReference(Record &R, + const RecordVal *RV, + unsigned Elt) const { assert(0 && "Illegal element reference off dag"); return 0; } @@ -1210,7 +1222,7 @@ class RecordVal { std::string Name; RecTy *Ty; unsigned Prefix; - Init *Value; + const Init *Value; public: RecordVal(const std::string &N, RecTy *T, unsigned P); @@ -1218,9 +1230,9 @@ public: unsigned getPrefix() const { return Prefix; } RecTy *getType() const { return Ty; } - Init *getValue() const { return Value; } + const Init *getValue() const { return Value; } - bool setValue(Init *V) { + bool setValue(const Init *V) { if (V) { Value = V->convertInitializerTo(Ty); return Value == 0; @@ -1359,7 +1371,7 @@ public: /// getValueInit - Return the initializer for a value with the specified name, /// or throw an exception if the field does not exist. /// - Init *getValueInit(StringRef FieldName) const; + 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 @@ -1371,13 +1383,13 @@ public: /// its value as a BitsInit, throwing an exception if the field does not exist /// or if the value is not the right type. /// - BitsInit *getValueAsBitsInit(StringRef FieldName) const; + 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. /// - ListInit *getValueAsListInit(StringRef FieldName) const; + 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 @@ -1419,7 +1431,7 @@ public: /// value as an Dag, throwing an exception if the field does not exist or if /// the value is not the right type. /// - DagInit *getValueAsDag(StringRef FieldName) const; + 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 diff --git a/utils/TableGen/RegisterInfoEmitter.cpp b/utils/TableGen/RegisterInfoEmitter.cpp index 9587245a25..74fe2d194c 100644 --- a/utils/TableGen/RegisterInfoEmitter.cpp +++ b/utils/TableGen/RegisterInfoEmitter.cpp @@ -166,7 +166,7 @@ RegisterInfoEmitter::EmitRegMapping(raw_ostream &OS, if (!V || !V->getValue()) continue; - DefInit *DI = dynamic_cast<DefInit*>(V->getValue()); + const DefInit *DI = dynamic_cast<const DefInit*>(V->getValue()); Record *Alias = DI->getDef(); DwarfRegNums[Reg] = DwarfRegNums[Alias]; } diff --git a/utils/TableGen/SetTheory.cpp b/utils/TableGen/SetTheory.cpp index 21ac09cb66..0287269c79 100644 --- a/utils/TableGen/SetTheory.cpp +++ b/utils/TableGen/SetTheory.cpp @@ -27,14 +27,14 @@ typedef SetTheory::RecVec RecVec; // (add a, b, ...) Evaluate and union all arguments. struct AddOp : public SetTheory::Operator { - void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) { + void apply(SetTheory &ST, const 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, DagInit *Expr, RecSet &Elts) { + void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) { if (Expr->arg_size() < 2) throw "Set difference needs at least two arguments: " + Expr->getAsString(); @@ -49,7 +49,7 @@ struct SubOp : public SetTheory::Operator { // (and S1, S2) Set intersection. struct AndOp : public SetTheory::Operator { - void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) { + void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) { if (Expr->arg_size() != 2) throw "Set intersection requires two arguments: " + Expr->getAsString(); RecSet S1, S2; @@ -63,16 +63,16 @@ struct AndOp : public SetTheory::Operator { // SetIntBinOp - Abstract base class for (Op S, N) operators. struct SetIntBinOp : public SetTheory::Operator { - virtual void apply2(SetTheory &ST, DagInit *Expr, + virtual void apply2(SetTheory &ST, const DagInit *Expr, RecSet &Set, int64_t N, RecSet &Elts) =0; - void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) { + void apply(SetTheory &ST, const 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); - IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[1]); + const IntInit *II = dynamic_cast<const IntInit*>(Expr->arg_begin()[1]); if (!II) throw "Second argument must be an integer: " + Expr->getAsString(); apply2(ST, Expr, Set, II->getValue(), Elts); @@ -81,7 +81,7 @@ struct SetIntBinOp : public SetTheory::Operator { // (shl S, N) Shift left, remove the first N elements. struct ShlOp : public SetIntBinOp { - void apply2(SetTheory &ST, DagInit *Expr, + void apply2(SetTheory &ST, const DagInit *Expr, RecSet &Set, int64_t N, RecSet &Elts) { if (N < 0) @@ -93,7 +93,7 @@ struct ShlOp : public SetIntBinOp { // (trunc S, N) Truncate after the first N elements. struct TruncOp : public SetIntBinOp { - void apply2(SetTheory &ST, DagInit *Expr, + void apply2(SetTheory &ST, const DagInit *Expr, RecSet &Set, int64_t N, RecSet &Elts) { if (N < 0) @@ -110,7 +110,7 @@ struct RotOp : public SetIntBinOp { RotOp(bool Rev) : Reverse(Rev) {} - void apply2(SetTheory &ST, DagInit *Expr, + void apply2(SetTheory &ST, const DagInit *Expr, RecSet &Set, int64_t N, RecSet &Elts) { if (Reverse) @@ -129,7 +129,7 @@ struct RotOp : public SetIntBinOp { // (decimate S, N) Pick every N'th element of S. struct DecimateOp : public SetIntBinOp { - void apply2(SetTheory &ST, DagInit *Expr, + void apply2(SetTheory &ST, const DagInit *Expr, RecSet &Set, int64_t N, RecSet &Elts) { if (N <= 0) @@ -141,25 +141,25 @@ struct DecimateOp : public SetIntBinOp { // (sequence "Format", From, To) Generate a sequence of records by name. struct SequenceOp : public SetTheory::Operator { - void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) { + void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) { if (Expr->arg_size() != 3) throw "Bad args to (sequence \"Format\", From, To): " + Expr->getAsString(); std::string Format; - if (StringInit *SI = dynamic_cast<StringInit*>(Expr->arg_begin()[0])) + if (const StringInit *SI = dynamic_cast<const StringInit*>(Expr->arg_begin()[0])) Format = SI->getValue(); else throw "Format must be a string: " + Expr->getAsString(); int64_t From, To; - if (IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[1])) + if (const IntInit *II = dynamic_cast<const 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 (IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[2])) + if (const IntInit *II = dynamic_cast<const IntInit*>(Expr->arg_begin()[2])) To = II->getValue(); else throw "From must be an integer: " + Expr->getAsString(); @@ -167,7 +167,7 @@ struct SequenceOp : public SetTheory::Operator { throw "To out of range"; RecordKeeper &Records = - dynamic_cast<DefInit&>(*Expr->getOperator()).getDef()->getRecords(); + dynamic_cast<const DefInit&>(*Expr->getOperator()).getDef()->getRecords(); int Step = From <= To ? 1 : -1; for (To += Step; From != To; From += Step) { @@ -222,9 +222,9 @@ void SetTheory::addFieldExpander(StringRef ClassName, StringRef FieldName) { addExpander(ClassName, new FieldExpander(FieldName)); } -void SetTheory::evaluate(Init *Expr, RecSet &Elts) { +void SetTheory::evaluate(const Init *Expr, RecSet &Elts) { // A def in a list can be a just an element, or it may expand. - if (DefInit *Def = dynamic_cast<DefInit*>(Expr)) { + if (const DefInit *Def = dynamic_cast<const DefInit*>(Expr)) { if (const RecVec *Result = expand(Def->getDef())) return Elts.insert(Result->begin(), Result->end()); Elts.insert(Def->getDef()); @@ -232,14 +232,14 @@ void SetTheory::evaluate(Init *Expr, RecSet &Elts) { } // Lists simply expand. - if (ListInit *LI = dynamic_cast<ListInit*>(Expr)) + if (const ListInit *LI = dynamic_cast<const ListInit*>(Expr)) return evaluate(LI->begin(), LI->end(), Elts); // Anything else must be a DAG. - DagInit *DagExpr = dynamic_cast<DagInit*>(Expr); + const DagInit *DagExpr = dynamic_cast<const DagInit*>(Expr); if (!DagExpr) throw "Invalid set element: " + Expr->getAsString(); - DefInit *OpInit = dynamic_cast<DefInit*>(DagExpr->getOperator()); + const DefInit *OpInit = dynamic_cast<const DefInit*>(DagExpr->getOperator()); if (!OpInit) throw "Bad set expression: " + Expr->getAsString(); Operator *Op = Operators.lookup(OpInit->getDef()->getName()); diff --git a/utils/TableGen/SetTheory.h b/utils/TableGen/SetTheory.h index 6e8313be07..f6123c7d91 100644 --- a/utils/TableGen/SetTheory.h +++ b/utils/TableGen/SetTheory.h @@ -70,7 +70,7 @@ public: /// apply - Apply this operator to Expr's arguments and insert the result /// in Elts. - virtual void apply(SetTheory&, DagInit *Expr, RecSet &Elts) =0; + virtual void apply(SetTheory&, const DagInit *Expr, RecSet &Elts) =0; }; /// Expander - A callback function that can transform a Record representing a @@ -115,7 +115,7 @@ public: void addOperator(StringRef Name, Operator*); /// evaluate - Evaluate Expr and append the resulting set to Elts. - void evaluate(Init *Expr, RecSet &Elts); + void evaluate(const Init *Expr, RecSet &Elts); /// evaluate - Evaluate a sequence of Inits and append to Elts. template<typename Iter> diff --git a/utils/TableGen/TGParser.cpp b/utils/TableGen/TGParser.cpp index d8f5d6301f..1565959a69 100644 --- a/utils/TableGen/TGParser.cpp +++ b/utils/TableGen/TGParser.cpp @@ -28,7 +28,7 @@ namespace llvm { struct SubClassReference { SMLoc RefLoc; Record *Rec; - std::vector<Init*> TemplateArgs; + std::vector<const Init*> TemplateArgs; SubClassReference() : Rec(0) {} bool isInvalid() const { return Rec == 0; } @@ -37,7 +37,7 @@ struct SubClassReference { struct SubMultiClassReference { SMLoc RefLoc; MultiClass *MC; - std::vector<Init*> TemplateArgs; + std::vector<const Init*> TemplateArgs; SubMultiClassReference() : MC(0) {} bool isInvalid() const { return MC == 0; } @@ -50,7 +50,7 @@ void SubMultiClassReference::dump() const { MC->dump(); errs() << "Template args:\n"; - for (std::vector<Init *>::const_iterator i = TemplateArgs.begin(), + for (std::vector<const Init *>::const_iterator i = TemplateArgs.begin(), iend = TemplateArgs.end(); i != iend; ++i) { @@ -80,7 +80,7 @@ bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) { /// SetValue - /// Return true on error, false on success. bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName, - const std::vector<unsigned> &BitList, Init *V) { + const std::vector<unsigned> &BitList, const Init *V) { if (!V) return false; if (CurRec == 0) CurRec = &CurMultiClass->Rec; @@ -92,7 +92,7 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName, // Do not allow assignments like 'X = X'. This will just cause infinite loops // in the resolution machinery. if (BitList.empty()) - if (VarInit *VI = dynamic_cast<VarInit*>(V)) + if (const VarInit *VI = dynamic_cast<const VarInit*>(V)) if (VI->getName() == ValName) return false; @@ -101,22 +101,22 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName, // initializer. // if (!BitList.empty()) { - BitsInit *CurVal = dynamic_cast<BitsInit*>(RV->getValue()); + const BitsInit *CurVal = dynamic_cast<const 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... - Init *BI = V->convertInitializerTo(BitsRecTy::get(BitList.size())); + const 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. - BitsInit *BInit = dynamic_cast<BitsInit*>(BI); + const BitsInit *BInit = dynamic_cast<const BitsInit*>(BI); assert(BInit != 0); - SmallVector<Init *, 16> NewBits(CurVal->getNumBits()); + SmallVector<const Init *, 16> NewBits(CurVal->getNumBits()); // Loop over bits, assigning values as appropriate. for (unsigned i = 0, e = BitList.size(); i != e; ++i) { @@ -131,7 +131,7 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName, if (NewBits[i] == 0) NewBits[i] = CurVal->getBit(i); - V = new BitsInit(ArrayRef<Init *>(NewBits)); + V = new BitsInit(ArrayRef<const Init *>(NewBits)); } if (RV->setValue(V)) @@ -633,7 +633,7 @@ RecTy *TGParser::ParseType() { /// IDValue ::= ID [multiclass template argument] /// IDValue ::= ID [def name] /// -Init *TGParser::ParseIDValue(Record *CurRec) { +const 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 @@ Init *TGParser::ParseIDValue(Record *CurRec) { /// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID /// has already been read. -Init *TGParser::ParseIDValue(Record *CurRec, +const Init *TGParser::ParseIDValue(Record *CurRec, const std::string &Name, SMLoc NameLoc) { if (CurRec) { if (const RecordVal *RV = CurRec->getValue(Name)) @@ -677,7 +677,7 @@ Init *TGParser::ParseIDValue(Record *CurRec, /// /// Operation ::= XOperator ['<' Type '>'] '(' Args ')' /// -Init *TGParser::ParseOperation(Record *CurRec) { +const Init *TGParser::ParseOperation(Record *CurRec) { switch (Lex.getCode()) { default: TokError("unknown operation"); @@ -724,15 +724,15 @@ Init *TGParser::ParseOperation(Record *CurRec) { } Lex.Lex(); // eat the '(' - Init *LHS = ParseValue(CurRec); + const Init *LHS = ParseValue(CurRec); if (LHS == 0) return 0; if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL || Code == UnOpInit::EMPTY) { - ListInit *LHSl = dynamic_cast<ListInit*>(LHS); - StringInit *LHSs = dynamic_cast<StringInit*>(LHS); - TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS); + const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS); + const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS); + const TypedInit *LHSt = dynamic_cast<const 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 @@ Init *TGParser::ParseOperation(Record *CurRec) { return 0; } if (LHSl) { - Init *Item = LHSl->getElement(0); - TypedInit *Itemt = dynamic_cast<TypedInit*>(Item); + const Init *Item = LHSl->getElement(0); + const TypedInit *Itemt = dynamic_cast<const TypedInit*>(Item); if (Itemt == 0) { TokError("untyped list element in unary operator"); return 0; @@ -825,7 +825,7 @@ Init *TGParser::ParseOperation(Record *CurRec) { } Lex.Lex(); // eat the '(' - SmallVector<Init*, 2> InitList; + SmallVector<const Init*, 2> InitList; InitList.push_back(ParseValue(CurRec)); if (InitList.back() == 0) return 0; @@ -847,7 +847,7 @@ Init *TGParser::ParseOperation(Record *CurRec) { // shorthand for nesting them. if (Code == BinOpInit::STRCONCAT) { while (InitList.size() > 2) { - Init *RHS = InitList.pop_back_val(); + const Init *RHS = InitList.pop_back_val(); RHS = (new BinOpInit(Code, InitList.back(), RHS, Type)) ->Fold(CurRec, CurMultiClass); InitList.back() = RHS; @@ -888,7 +888,7 @@ Init *TGParser::ParseOperation(Record *CurRec) { } Lex.Lex(); // eat the '(' - Init *LHS = ParseValue(CurRec); + const Init *LHS = ParseValue(CurRec); if (LHS == 0) return 0; if (Lex.getCode() != tgtok::comma) { @@ -897,7 +897,7 @@ Init *TGParser::ParseOperation(Record *CurRec) { } Lex.Lex(); // eat the ',' - Init *MHS = ParseValue(CurRec); + const Init *MHS = ParseValue(CurRec); if (MHS == 0) return 0; if (Lex.getCode() != tgtok::comma) { @@ -906,7 +906,7 @@ Init *TGParser::ParseOperation(Record *CurRec) { } Lex.Lex(); // eat the ',' - Init *RHS = ParseValue(CurRec); + const Init *RHS = ParseValue(CurRec); if (RHS == 0) return 0; if (Lex.getCode() != tgtok::r_paren) { @@ -920,23 +920,23 @@ Init *TGParser::ParseOperation(Record *CurRec) { case tgtok::XIf: { // FIXME: The `!if' operator doesn't handle non-TypedInit well at // all. This can be made much more robust. - TypedInit *MHSt = dynamic_cast<TypedInit*>(MHS); - TypedInit *RHSt = dynamic_cast<TypedInit*>(RHS); + const TypedInit *MHSt = dynamic_cast<const TypedInit*>(MHS); + const TypedInit *RHSt = dynamic_cast<const TypedInit*>(RHS); RecTy *MHSTy = 0; RecTy *RHSTy = 0; if (MHSt == 0 && RHSt == 0) { - BitsInit *MHSbits = dynamic_cast<BitsInit*>(MHS); - BitsInit *RHSbits = dynamic_cast<BitsInit*>(RHS); + const BitsInit *MHSbits = dynamic_cast<const BitsInit*>(MHS); + const BitsInit *RHSbits = dynamic_cast<const BitsInit*>(RHS); if (MHSbits && RHSbits && MHSbits->getNumBits() == RHSbits->getNumBits()) { Type = BitRecTy::get(); break; } else { - BitInit *MHSbit = dynamic_cast<BitInit*>(MHS); - BitInit *RHSbit = dynamic_cast<BitInit*>(RHS); + const BitInit *MHSbit = dynamic_cast<const BitInit*>(MHS); + const BitInit *RHSbit = dynamic_cast<const BitInit*>(RHS); if (MHSbit && RHSbit) { Type = BitRecTy::get(); @@ -964,7 +964,7 @@ Init *TGParser::ParseOperation(Record *CurRec) { break; } case tgtok::XForEach: { - TypedInit *MHSt = dynamic_cast<TypedInit *>(MHS); + const TypedInit *MHSt = dynamic_cast<const TypedInit *>(MHS); if (MHSt == 0) { TokError("could not get type for !foreach"); return 0; @@ -973,7 +973,7 @@ Init *TGParser::ParseOperation(Record *CurRec) { break; } case tgtok::XSubst: { - TypedInit *RHSt = dynamic_cast<TypedInit *>(RHS); + const TypedInit *RHSt = dynamic_cast<const TypedInit *>(RHS); if (RHSt == 0) { TokError("could not get type for !subst"); return 0; @@ -1038,8 +1038,8 @@ RecTy *TGParser::ParseOperatorType() { /// SimpleValue ::= SRLTOK '(' Value ',' Value ')' /// SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')' /// -Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) { - Init *R = 0; +const Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) { + const Init *R = 0; switch (Lex.getCode()) { default: TokError("Unknown token when parsing a value"); break; case tgtok::IntVal: R = new IntInit(Lex.getCurIntVal()); Lex.Lex(); break; @@ -1085,7 +1085,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) { return 0; } - std::vector<Init*> ValueList = ParseValueList(CurRec, Class); + std::vector<const Init*> ValueList = ParseValueList(CurRec, Class); if (ValueList.empty()) return 0; if (Lex.getCode() != tgtok::greater) { @@ -1115,7 +1115,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) { case tgtok::l_brace: { // Value ::= '{' ValueList '}' SMLoc BraceLoc = Lex.getLoc(); Lex.Lex(); // eat the '{' - std::vector<Init*> Vals; + std::vector<const Init*> Vals; if (Lex.getCode() != tgtok::r_brace) { Vals = ParseValueList(CurRec); @@ -1127,10 +1127,10 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) { } Lex.Lex(); // eat the '}' - SmallVector<Init *, 16> NewBits(Vals.size()); + SmallVector<const Init *, 16> NewBits(Vals.size()); for (unsigned i = 0, e = Vals.size(); i != e; ++i) { - Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get()); + const Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get()); if (Bit == 0) { Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+ ") is not convertable to a bit"); @@ -1138,11 +1138,11 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) { } NewBits[Vals.size()-i-1] = Bit; } - return new BitsInit(ArrayRef<Init *>(NewBits)); + return new BitsInit(ArrayRef<const Init *>(NewBits)); } case tgtok::l_square: { // Value ::= '[' ValueList ']' Lex.Lex(); // eat the '[' - std::vector<Init*> Vals; + std::vector<const Init*> Vals; RecTy *DeducedEltTy = 0; ListRecTy *GivenListTy = 0; @@ -1190,10 +1190,10 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) { // Check elements RecTy *EltTy = 0; - for (std::vector<Init *>::iterator i = Vals.begin(), ie = Vals.end(); + for (std::vector<const Init *>::iterator i = Vals.begin(), ie = Vals.end(); i != ie; ++i) { - TypedInit *TArg = dynamic_cast<TypedInit*>(*i); + const TypedInit *TArg = dynamic_cast<const TypedInit*>(*i); if (TArg == 0) { TokError("Untyped list element"); return 0; @@ -1246,7 +1246,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) { return 0; } - Init *Operator = ParseValue(CurRec); + const Init *Operator = ParseValue(CurRec); if (Operator == 0) return 0; // If the operator name is present, parse it. @@ -1260,7 +1260,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) { Lex.Lex(); // eat the VarName. } - std::vector<std::pair<llvm::Init*, std::string> > DagArgs; + std::vector<std::pair<const llvm::Init*, std::string> > DagArgs; if (Lex.getCode() != tgtok::r_paren) { DagArgs = ParseDagArgList(CurRec); if (DagArgs.empty()) return 0; @@ -1302,8 +1302,8 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) { /// ValueSuffix ::= '[' BitList ']' /// ValueSuffix ::= '.' ID /// -Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) { - Init *Result = ParseSimpleValue(CurRec, ItemType); +const Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) { + const Init *Result = ParseSimpleValue(CurRec, ItemType); if (Result == 0) return 0; // Parse the suffixes now if present. @@ -1373,20 +1373,20 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) { /// /// ParseDagArgList ::= Value (':' VARNAME)? /// ParseDagArgList ::= ParseDagArgList ',' Value (':' VARNAME)? -std::vector<std::pair<llvm::Init*, std::string> > +std::vector<std::pair<const llvm::Init*, std::string> > TGParser::ParseDagArgList(Record *CurRec) { - std::vector<std::pair<llvm::Init*, std::string> > Result; + std::vector<std::pair<const llvm::Init*, std::string> > Result; while (1) { - Init *Val = ParseValue(CurRec); - if (Val == 0) return std::vector<std::pair<llvm::Init*, std::string> >(); + const Init *Val = ParseValue(CurRec); + if (Val == 0) return std::vector<std::pair<const 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<llvm::Init*, std::string> >(); + return std::vector<std::pair<const llvm::Init*, std::string> >(); } VarName = Lex.getCurStrVal(); Lex.Lex(); // eat the VarName. @@ -1408,9 +1408,9 @@ TGParser::ParseDagArgList(Record *CurRec) { /// /// ValueList ::= Value (',' Value) /// -std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, +std::vector<const Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, RecTy *EltTy) { - std::vector<Init*> Result; + std::vector<const Init*> Result; RecTy *ItemType = EltTy; unsigned int ArgN = 0; if (ArgsRec != 0 && EltTy == 0) { @@ -1421,7 +1421,7 @@ std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, ++ArgN; } Result.push_back(ParseValue(CurRec, ItemType)); - if (Result.back() == 0) return std::vector<Init*>(); + if (Result.back() == 0) return std::vector<const Init*>(); while (Lex.getCode() == tgtok::comma) { Lex.Lex(); // Eat the comma @@ -1430,7 +1430,7 @@ std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, const std::vector<std::string> &TArgs = ArgsRec->getTemplateArgs(); if (ArgN >= TArgs.size()) { TokError("too many template arguments"); - return std::vector<Init*>(); + return std::vector<const Init*>(); } const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]); assert(RV && "Template argument record not found??"); @@ -1438,7 +1438,7 @@ std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec, ++ArgN; } Result.push_back(ParseValue(CurRec, ItemType)); - if (Result.back() == 0) return std::vector<Init*>(); + if (Result.back() == 0) return std::vector<const Init*>(); } return Result; @@ -1491,7 +1491,7 @@ std::string TGParser::ParseDeclaration(Record *CurRec, if (Lex.getCode() == tgtok::equal) { Lex.Lex(); SMLoc ValLoc = Lex.getLoc(); - Init *Val = ParseValue(CurRec, Type); + const Init *Val = ParseValue(CurRec, Type); if (Val == 0 || SetValue(CurRec, ValLoc, DeclName, std::vector<unsigned>(), Val)) return ""; @@ -1575,7 +1575,7 @@ bool TGParser::ParseBodyItem(Record *CurRec) { RecTy *Type = Field->getType(); - Init *Val = ParseValue(CurRec, Type); + const Init *Val = ParseValue(CurRec, Type); if (Val == 0) return true; if (Lex.getCode() != tgtok::semi) @@ -1775,7 +1775,7 @@ std::vector<LetRecord> TGParser::ParseLetList() { } Lex.Lex(); // eat the '='. - Init *Val = ParseValue(0); + const Init *Val = ParseValue(0); if (Val == 0) return std::vector<LetRecord>(); // Now that we have everything, add the record. @@ -1949,7 +1949,7 @@ bool TGParser::ParseDefm(MultiClass *CurMultiClass) { // template parameters. MultiClass *MC = MultiClasses[Ref.Rec->getName()]; assert(MC && "Didn't lookup multiclass correctly?"); - std::vector<Init*> &TemplateVals = Ref.TemplateArgs; + std::vector<const Init*> &TemplateVals = Ref.TemplateArgs; // Verify that the correct number of template arguments were specified. const std::vector<std::string> &TArgs = MC->Rec.getTemplateArgs(); diff --git a/utils/TableGen/TGParser.h b/utils/TableGen/TGParser.h index 8b56b8a329..17de468a05 100644 --- a/utils/TableGen/TGParser.h +++ b/utils/TableGen/TGParser.h @@ -33,9 +33,9 @@ namespace llvm { struct LetRecord { std::string Name; std::vector<unsigned> Bits; - Init *Value; + const Init *Value; SMLoc Loc; - LetRecord(const std::string &N, const std::vector<unsigned> &B, Init *V, + LetRecord(const std::string &N, const std::vector<unsigned> &B, const Init *V, SMLoc L) : Name(N), Bits(B), Value(V), Loc(L) { } @@ -73,7 +73,7 @@ public: private: // Semantic analysis methods. bool AddValue(Record *TheRec, SMLoc Loc, const RecordVal &RV); bool SetValue(Record *TheRec, SMLoc Loc, const std::string &ValName, - const std::vector<unsigned> &BitList, Init *V); + const std::vector<unsigned> &BitList, const Init *V); bool AddSubClass(Record *Rec, SubClassReference &SubClass); bool AddSubMultiClass(MultiClass *CurMC, SubMultiClassReference &SubMultiClass); @@ -98,18 +98,18 @@ private: // Parser methods. SubClassReference ParseSubClassReference(Record *CurRec, bool isDefm); SubMultiClassReference ParseSubMultiClassReference(MultiClass *CurMC); - 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 *); + 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 *); bool ParseOptionalRangeList(std::vector<unsigned> &Ranges); bool ParseOptionalBitList(std::vector<unsigned> &Ranges); std::vector<unsigned> ParseRangeList(); bool ParseRangePiece(std::vector<unsigned> &Ranges); RecTy *ParseType(); - Init *ParseOperation(Record *CurRec); + const Init *ParseOperation(Record *CurRec); RecTy *ParseOperatorType(); std::string ParseObjectName(); Record *ParseClassID(); diff --git a/utils/TableGen/X86RecognizableInstr.cpp b/utils/TableGen/X86RecognizableInstr.cpp index 3071d8e274..998476954e 100644 --- a/utils/TableGen/X86RecognizableInstr.cpp +++ b/utils/TableGen/X86RecognizableInstr.cpp @@ -162,7 +162,7 @@ static bool isRegFormat(uint8_t form) { /// @param init - A reference to the BitsInit to be decoded. /// @return - The field, with the first bit in the BitsInit as the lowest /// order bit. -static uint8_t byteFromBitsInit(BitsInit &init) { +static uint8_t byteFromBitsInit(const BitsInit &init) { int width = init.getNumBits(); assert(width <= 8 && "Field is too large for uint8_t!"); @@ -173,7 +173,7 @@ static uint8_t byteFromBitsInit(BitsInit &init) { uint8_t ret = 0; for (index = 0; index < width; index++) { - if (static_cast<BitInit*>(init.getBit(index))->getValue()) + if (static_cast<const BitInit*>(init.getBit(index))->getValue()) ret |= mask; mask <<= 1; @@ -189,7 +189,7 @@ static uint8_t byteFromBitsInit(BitsInit &init) { /// @param name - The name of the field in the record. /// @return - The field, as translated by byteFromBitsInit(). static uint8_t byteFromRec(const Record* rec, const std::string &name) { - BitsInit* bits = rec->getValueAsBitsInit(name); + const BitsInit* bits = rec->getValueAsBitsInit(name); return byteFromBitsInit(*bits); } |