summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorDavid Greene <greened@obbligato.org>2011-07-11 18:25:51 +0000
committerDavid Greene <greened@obbligato.org>2011-07-11 18:25:51 +0000
commitd4a9066c93da9a5aab47ca228d82e796fdec70c0 (patch)
treef4533e3a9fe75aa310bd4682b254a053af0bfd73
parent7ae0df41422193e65231a0f9526bfe66067c6532 (diff)
downloadllvm-d4a9066c93da9a5aab47ca228d82e796fdec70c0.tar.gz
llvm-d4a9066c93da9a5aab47ca228d82e796fdec70c0.tar.bz2
llvm-d4a9066c93da9a5aab47ca228d82e796fdec70c0.tar.xz
[AVX] Make Inits Foldable
Manage Inits in a FoldingSet. This provides several benefits: - Memory for Inits is properly managed - Duplicate Inits are folded into Flyweights, saving memory - It enforces const-correctness, protecting against certain classes of bugs The above benefits allow Inits to be used in more contexts, which in turn provides more dynamism to TableGen. This enhanced capability will be used by the AVX code generator to a fold common patterns together. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134907 91177308-0d34-0410-b5e6-96231b3b80d8
-rw-r--r--utils/TableGen/ARMDecoderEmitter.cpp21
-rw-r--r--utils/TableGen/AsmMatcherEmitter.cpp24
-rw-r--r--utils/TableGen/CallingConvEmitter.cpp10
-rw-r--r--utils/TableGen/ClangAttrEmitter.cpp10
-rw-r--r--utils/TableGen/ClangDiagnosticsEmitter.cpp8
-rw-r--r--utils/TableGen/ClangSACheckersEmitter.cpp30
-rw-r--r--utils/TableGen/CodeEmitterGen.cpp38
-rw-r--r--utils/TableGen/CodeEmitterGen.h6
-rw-r--r--utils/TableGen/CodeGenDAGPatterns.cpp121
-rw-r--r--utils/TableGen/CodeGenDAGPatterns.h18
-rw-r--r--utils/TableGen/CodeGenInstruction.cpp39
-rw-r--r--utils/TableGen/CodeGenInstruction.h8
-rw-r--r--utils/TableGen/CodeGenRegisters.cpp31
-rw-r--r--utils/TableGen/CodeGenTarget.cpp4
-rw-r--r--utils/TableGen/DAGISelMatcherGen.cpp13
-rw-r--r--utils/TableGen/FastISelEmitter.cpp8
-rw-r--r--utils/TableGen/FixedLenDecoderEmitter.cpp33
-rw-r--r--utils/TableGen/InstrInfoEmitter.cpp8
-rw-r--r--utils/TableGen/LLVMCConfigurationEmitter.cpp46
-rw-r--r--utils/TableGen/OptParserEmitter.cpp16
-rw-r--r--utils/TableGen/PseudoLoweringEmitter.cpp14
-rw-r--r--utils/TableGen/PseudoLoweringEmitter.h2
-rw-r--r--utils/TableGen/Record.cpp968
-rw-r--r--utils/TableGen/Record.h974
-rw-r--r--utils/TableGen/RegisterInfoEmitter.cpp2
-rw-r--r--utils/TableGen/SetTheory.cpp41
-rw-r--r--utils/TableGen/SetTheory.h4
-rw-r--r--utils/TableGen/TGParser.cpp166
-rw-r--r--utils/TableGen/TGParser.h24
-rw-r--r--utils/TableGen/TableGen.cpp13
-rw-r--r--utils/TableGen/X86RecognizableInstr.cpp6
31 files changed, 1708 insertions, 998 deletions
diff --git a/utils/TableGen/ARMDecoderEmitter.cpp b/utils/TableGen/ARMDecoderEmitter.cpp
index 8a5dc8ba15..3721ed41b2 100644
--- a/utils/TableGen/ARMDecoderEmitter.cpp
+++ b/utils/TableGen/ARMDecoderEmitter.cpp
@@ -114,7 +114,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!");
@@ -125,7 +125,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;
@@ -135,12 +135,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;
}
@@ -183,15 +183,15 @@ static bool ValueNotSet(bit_value_t V) {
static int Value(bit_value_t V) {
return ValueNotSet(V) ? -1 : (V == BIT_FALSE ? 0 : 1);
}
-static bit_value_t bitFromBits(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--) {
@@ -424,7 +424,8 @@ 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);
@@ -1558,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 d9c3b84d6c..3236a199bb 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 26bd8786a4..bca4bb61c2 100644
--- a/utils/TableGen/ClangAttrEmitter.cpp
+++ b/utils/TableGen/ClangAttrEmitter.cpp
@@ -21,17 +21,19 @@ 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;
Strings.reserve(List->getSize());
- for (ListInit::iterator i = List->begin(), e = List->end(); i != e; ++i) {
+ for (ListInit::const_iterator i = List->begin(), e = List->end();
+ 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..debed97d67 100644
--- a/utils/TableGen/ClangDiagnosticsEmitter.cpp
+++ b/utils/TableGen/ClangDiagnosticsEmitter.cpp
@@ -74,7 +74,8 @@ 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 +160,8 @@ 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 +227,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..fe54b3689a 100644
--- a/utils/TableGen/ClangSACheckersEmitter.cpp
+++ b/utils/TableGen/ClangSACheckersEmitter.cpp
@@ -28,7 +28,8 @@ 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 +43,8 @@ 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 +65,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 +131,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 +151,23 @@ 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 +208,8 @@ 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 +237,8 @@ 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 d828dfc25d..4b67854d3e 100644
--- a/utils/TableGen/CodeEmitterGen.cpp
+++ b/utils/TableGen/CodeEmitterGen.cpp
@@ -38,21 +38,25 @@ 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();
- BitsInit *NewBI = new BitsInit(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);
- NewBI->setBit(bit, BitSwap);
- NewBI->setBit(bitSwapIdx, OrigBit);
+ const Init *OrigBit = BI->getBit(bit);
+ const Init *BitSwap = BI->getBit(bitSwapIdx);
+ NewBits[bit] = BitSwap;
+ NewBits[bitSwapIdx] = OrigBit;
}
if (numBits % 2) {
unsigned middle = (numBits + 1) / 2;
- NewBI->setBit(middle, BI->getBit(middle));
+ NewBits[middle] = BI->getBit(middle);
}
+
+ const BitsInit *NewBI = BitsInit::Create(NewBits.begin(), NewBits.end());
// Update the bits in reversed order so that emitInstrOpBits will get the
// correct endianness.
@@ -63,12 +67,14 @@ 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;
}
@@ -77,8 +83,8 @@ int CodeEmitterGen::getVariableBit(const std::string &VarName,
}
void CodeEmitterGen::
-AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName,
- unsigned &NumberedOp,
+AddCodeToMergeInOperand(Record *R, const BitsInit *BI,
+ const std::string &VarName, unsigned &NumberedOp,
std::string &Case, CodeGenTarget &Target) {
CodeGenInstruction &CGI = Target.getInstruction(R);
@@ -181,7 +187,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;
@@ -238,12 +244,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..af890bfe24 100644
--- a/utils/TableGen/CodeEmitterGen.h
+++ b/utils/TableGen/CodeEmitterGen.h
@@ -35,11 +35,11 @@ private:
void emitMachineOpEmitter(raw_ostream &o, const std::string &Namespace);
void emitGetValueBit(raw_ostream &o, const std::string &Namespace);
void reverseBits(std::vector<Record*> &Insts);
- int getVariableBit(const std::string &VarName, 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,
- unsigned &NumberedOp,
+ 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 072893fe5a..a73da717c1 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,8 @@ 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 +867,13 @@ 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 +1023,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 +1100,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 +1157,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 +1321,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 +1331,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 +1384,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 +1393,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 +1653,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 +1703,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,16 +1741,17 @@ 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
// TreePatternNode of its own. For example:
/// (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> >()),
+ return ParseTreePattern(DagInit::Create(DI, "",
+ std::vector<std::pair<const Init*, std::string> >()),
OpName);
// Input argument?
@@ -1763,26 +1766,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(new IntRecTy());
- if (II == 0 || !dynamic_cast<IntInit*>(II))
+ const Init *II = BI->convertInitializerTo(new IntRecTy());
+ 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();
@@ -1860,7 +1863,7 @@ TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){
else // Otherwise, no chain.
Operator = getDAGPatterns().get_intrinsic_wo_chain_sdnode();
- TreePatternNode *IIDNode = new TreePatternNode(new IntInit(IID), 1);
+ TreePatternNode *IIDNode = new TreePatternNode(IntInit::Create(IID), 1);
Children.insert(Children.begin(), IIDNode);
}
@@ -1947,7 +1950,8 @@ 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 +2100,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 +2112,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 +2125,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 +2184,19 @@ void CodeGenDAGPatterns::ParseDefaultOperands() {
// Find some SDNode.
assert(!SDNodes.empty() && "No SDNodes parsed?");
- Init *SomeSDNode = new DefInit(SDNodes.begin()->first);
+ const Init *SomeSDNode = DefInit::Create(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 = DagInit::Create(SomeSDNode, "", Ops);
// Create a TreePattern to parse this.
TreePattern P(DefaultOps[iter][i], DI, false, *this);
@@ -2231,7 +2235,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 +2245,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 +2263,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 +2298,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 +2339,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 +2405,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 +2422,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 +2529,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 +2623,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 +2668,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 +2869,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 +3187,8 @@ 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 e4e8574bbc..f517219ee7 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 d1e63a9bd8..c723c36617 100644
--- a/utils/TableGen/CodeGenInstruction.cpp
+++ b/utils/TableGen/CodeGenInstruction.cpp
@@ -30,9 +30,10 @@ 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 +41,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 +51,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 +61,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!";
@@ -68,7 +69,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
std::string PrintMethod = "printOperand";
std::string EncoderMethod;
unsigned NumOps = 1;
- DagInit *MIOpInfo = 0;
+ const DagInit *MIOpInfo = 0;
if (Rec->isSubClassOf("RegisterOperand")) {
PrintMethod = Rec->getValueAsString("PrintMethod");
} else if (Rec->isSubClassOf("Operand")) {
@@ -78,8 +79,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";
@@ -178,7 +179,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 + "'";
@@ -400,12 +401,13 @@ 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
@@ -451,7 +453,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.
@@ -470,7 +472,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");
@@ -480,7 +482,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)
@@ -519,11 +521,12 @@ 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 e00b631247..797be7c612 100644
--- a/utils/TableGen/CodeGenInstruction.h
+++ b/utils/TableGen/CodeGenInstruction.h
@@ -94,7 +94,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.
@@ -102,7 +102,7 @@ namespace llvm {
OperandInfo(Record *R, const std::string &N, const std::string &PMN,
const std::string &EMN, unsigned MION, unsigned MINO,
- DagInit *MIOI)
+ const DagInit *MIOI)
: Rec(R), Name(N), PrinterMethodName(PMN), EncoderMethodName(EMN),
MIOperandNo(MION), MINumOperands(MINO), MIOperandInfo(MIOI) {}
@@ -265,7 +265,7 @@ namespace llvm {
std::string AsmString;
/// Result - The result instruction.
- DagInit *Result;
+ const DagInit *Result;
/// ResultInst - The instruction generated by the alias (decoded from
/// Result).
@@ -311,7 +311,7 @@ namespace llvm {
CodeGenInstAlias(Record *R, CodeGenTarget &T);
- bool tryAliasOpMatch(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 1acf3a85b6..2e82ae5a3a 100644
--- a/utils/TableGen/CodeGenRegisters.cpp
+++ b/utils/TableGen/CodeGenRegisters.cpp
@@ -91,14 +91,15 @@ 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 +108,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 +164,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,19 +184,19 @@ struct TupleExpander : SetTheory::Expander {
// Precompute some types.
Record *RegisterCl = Def->getRecords().getClass("Register");
RecTy *RegisterRecTy = new RecordRecTy(RegisterCl);
- StringInit *BlankName = new StringInit("");
+ const StringInit *BlankName = StringInit::Create("");
// 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];
if (i) Name += '_';
Name += Reg->getName();
- Tuple.push_back(new DefInit(Reg));
+ Tuple.push_back(DefInit::Create(Reg));
CostPerUse = std::max(CostPerUse,
unsigned(Reg->getValueAsInt("CostPerUse")));
}
@@ -216,7 +217,7 @@ struct TupleExpander : SetTheory::Expander {
// Replace the sub-register list with Tuple.
if (RV.getName() == "SubRegs")
- RV.setValue(new ListInit(Tuple, RegisterRecTy));
+ RV.setValue(ListInit::Create(Tuple, RegisterRecTy));
// Provide a blank AsmName. MC hacks are required anyway.
if (RV.getName() == "AsmName")
@@ -224,7 +225,7 @@ struct TupleExpander : SetTheory::Expander {
// CostPerUse is aggregated from all Tuple members.
if (RV.getName() == "CostPerUse")
- RV.setValue(new IntInit(CostPerUse));
+ RV.setValue(IntInit::Create(CostPerUse));
// Copy fields from the RegisterTuples def.
if (RV.getName() == "SubRegIndices" ||
@@ -278,7 +279,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 +296,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 +308,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..1c841252e9 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,8 @@ 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 +497,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 +573,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 c9dcb01de0..e4b6f12891 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;
}
@@ -279,7 +279,8 @@ 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 < BIT_WIDTH; ++i)
Insn[i] = bitFromBits(Bits, i);
@@ -1230,7 +1231,7 @@ bool FixedLenDecoderEmitter::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;
@@ -1251,16 +1252,16 @@ bool FixedLenDecoderEmitter::populateInstruction(const CodeGenInstruction &CGI,
// Gather the outputs/inputs of the instruction, so we can find their
// positions in the encoding. This assumes for now that they appear in the
// MCInst in the order that they're listed.
- std::vector<std::pair<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)
InOutOperands.push_back(std::make_pair(In->getArg(i), In->getArgName(i)));
// For each operand, see if we can figure out where it is encoded.
- for (std::vector<std::pair<Init*, std::string> >::iterator
+ for (std::vector<std::pair<const Init*, std::string> >::iterator
NI = InOutOperands.begin(), NE = InOutOperands.end(); NI != NE; ++NI) {
unsigned PrevBit = ~0;
unsigned Base = ~0;
@@ -1268,10 +1269,10 @@ bool FixedLenDecoderEmitter::populateInstruction(const CodeGenInstruction &CGI,
std::string Decoder = "";
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) continue;
- VarInit *Var = dynamic_cast<VarInit*>(BI->getVariable());
+ const VarInit *Var = dynamic_cast<const VarInit*>(BI->getVariable());
assert(Var);
unsigned CurrBit = BI->getBitNum();
if (Var->getName() != NI->second) continue;
@@ -1301,7 +1302,7 @@ bool FixedLenDecoderEmitter::populateInstruction(const CodeGenInstruction &CGI,
// for decoding register classes.
// FIXME: This need to be extended to handle instructions with custom
// decoder methods, and operands with (simple) MIOperandInfo's.
- 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;
@@ -1313,8 +1314,8 @@ bool FixedLenDecoderEmitter::populateInstruction(const CodeGenInstruction &CGI,
}
RecordVal *DecoderString = TypeRecord->getValue("DecoderMethod");
- StringInit *String = DecoderString ?
- dynamic_cast<StringInit*>(DecoderString->getValue()) :
+ const StringInit *String = DecoderString ?
+ dynamic_cast<const StringInit*>(DecoderString->getValue()) :
0;
if (!isReg && String && String->getValue() != "")
Decoder = String->getValue();
diff --git a/utils/TableGen/InstrInfoEmitter.cpp b/utils/TableGen/InstrInfoEmitter.cpp
index 18d4db080a..3dcdeaa911 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;
}
}
@@ -288,11 +288,11 @@ void InstrInfoEmitter::emitRecord(const CodeGenInstruction &Inst, unsigned Num,
if (Inst.hasExtraDefRegAllocReq) OS << "|(1<<MCID::ExtraDefRegAllocReq)";
// Emit all of the target-specific flags...
- 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 090faf5085..91803309cb 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..6f89e01fa2 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,13 @@ 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 +79,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 730eca1b3c..2250250518 100644
--- a/utils/TableGen/Record.cpp
+++ b/utils/TableGen/Record.cpp
@@ -15,6 +15,8 @@
#include "Error.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Format.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringExtras.h"
using namespace llvm;
@@ -25,7 +27,7 @@ using namespace llvm;
void RecTy::dump() const { print(errs()); }
-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);
}
@@ -34,14 +36,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);
+ return BitInit::Create(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;
@@ -51,19 +53,21 @@ std::string BitsRecTy::getAsString() const {
return "bits<" + utostr(Size) + ">";
}
-Init *BitsRecTy::convertValue(UnsetInit *UI) {
- BitsInit *Ret = new BitsInit(Size);
+const Init *BitsRecTy::convertValue(const UnsetInit *UI) {
+ SmallVector<const Init *, 16> Bits(Size);
for (unsigned i = 0; i != Size; ++i)
- Ret->setBit(i, new UnsetInit());
- return Ret;
+ Bits[i] = UnsetInit::Create();
+
+ return BitsInit::Create(Bits.begin(), Bits.end());
}
-Init *BitsRecTy::convertValue(BitInit *UI) {
+const Init *BitsRecTy::convertValue(const BitInit *UI) {
if (Size != 1) return 0; // Can only convert single bit.
- BitsInit *Ret = new BitsInit(1);
- Ret->setBit(0, UI);
- return Ret;
+
+ const Init *Bits[1] = { UI };
+
+ return BitsInit::Create(Bits, array_endof(Bits));
}
/// canFitInBitfield - Return true if the number of bits is large enough to hold
@@ -74,82 +78,85 @@ static bool canFitInBitfield(int64_t Value, unsigned NumBits) {
(Value >> NumBits == 0) || (Value >> (NumBits-1) == -1);
}
-/// convertValue from Int initializer to bits type: Split the integer up into the
-/// appropriate bits.
+/// 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;
- BitsInit *Ret = new BitsInit(Size);
+ SmallVector<const Init *, 16> Bits(Size);
+
for (unsigned i = 0; i != Size; ++i)
- Ret->setBit(i, new BitInit(Value & (1LL << i)));
+ Bits[i] = BitInit::Create(Value & (1LL << i));
- return Ret;
+ return BitsInit::Create(Bits.begin(), Bits.end());
}
-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) {
- BitsInit *Ret = new BitsInit(Size);
+ SmallVector<const Init *, 16> Bits(Size);
+
for (unsigned i = 0; i != Size; ++i)
- Ret->setBit(i, new VarBitInit(VI, i));
- return Ret;
+ Bits[i] = VarBitInit::Create(VI, i);
+ return BitsInit::Create(Bits.begin(), Bits.end());
}
if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType())) {
- BitsInit *Ret = new BitsInit(1);
- Ret->setBit(0, VI);
- return Ret;
+ const Init *Bits[1] = { VI };
+
+ return BitsInit::Create(Bits, array_endof(Bits));
}
- 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)) {
- BitsInit *Ret = new BitsInit(Size);
+ SmallVector<const Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
- Ret->setBit(i, new TernOpInit(TernOpInit::IF, LHS,
- new IntInit((MHSVal & (1LL << i)) ? 1 : 0),
- new IntInit((RHSVal & (1LL << i)) ? 1 : 0),
- VI->getType()));
-
- return Ret;
+ NewBits[i] =
+ TernOpInit::Create(TernOpInit::IF, LHS,
+ IntInit::Create((MHSVal & (1LL << i)) ? 1 : 0),
+ IntInit::Create((RHSVal & (1LL << i)) ? 1 : 0),
+ VI->getType());
+
+ return BitsInit::Create(NewBits.begin(), NewBits.end());
}
} 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) {
- BitsInit *Ret = new BitsInit(Size);
+ SmallVector<const Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
- Ret->setBit(i, new TernOpInit(TernOpInit::IF, LHS,
- MHSbs->getBit(i),
- RHSbs->getBit(i),
- VI->getType()));
+ NewBits[i] = TernOpInit::Create(TernOpInit::IF, LHS,
+ MHSbs->getBit(i),
+ RHSbs->getBit(i),
+ VI->getType());
- return Ret;
+ return BitsInit::Create(NewBits.begin(), NewBits.end());
}
}
}
@@ -158,54 +165,54 @@ Init *BitsRecTy::convertValue(TypedInit *VI) {
return 0;
}
-Init *IntRecTy::convertValue(BitInit *BI) {
- return new IntInit(BI->getValue());
+const Init *IntRecTy::convertValue(const BitInit *BI) {
+ return IntInit::Create(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;
}
- return new IntInit(Result);
+ return IntInit::Create(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 UnOpInit::Create(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 BinOpInit::Create(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;
@@ -215,13 +222,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;
@@ -231,10 +238,10 @@ Init *ListRecTy::convertValue(ListInit *LI) {
return 0;
}
- return new ListInit(Elements, new ListRecTy(Ty));
+ return ListInit::Create(Elements, new ListRecTy(Ty));
}
-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()))
@@ -242,36 +249,36 @@ 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);
+ return UnOpInit::Create(UnOpInit::CAST, L, new DagRecTy);
return 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);
+ return BinOpInit::Create(BinOpInit::CONCAT, L, R, new DagRecTy);
return BO;
}
return 0;
@@ -281,14 +288,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()) ||
@@ -367,25 +374,59 @@ RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
// Initializer implementations
//===----------------------------------------------------------------------===//
+FoldingSet<Init> Init::UniqueInits;
+BumpPtrAllocator Init::InitAllocator;
+
void Init::dump() const { return print(errs()); }
-Init *BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
- BitsInit *BI = new BitsInit(Bits.size());
+const UnsetInit *UnsetInit::Create() {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initUnset);
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const UnsetInit *>(I);
+
+ UnsetInit *I = InitAllocator.Allocate<UnsetInit>();
+ new (I) UnsetInit(ID);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
+const BitInit *BitInit::Create(bool V) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initBit);
+ ID.AddBoolean(V);
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const BitInit *>(I);
+
+ BitInit *I = InitAllocator.Allocate<BitInit>();
+ new (I) BitInit(ID, V);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
+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()) {
- delete BI;
return 0;
}
- BI->setBit(i, getBit(Bits[i]));
+ NewBits[i] = getBit(Bits[i]);
}
- return BI;
+
+ return BitsInit::Create(NewBits.begin(), NewBits.end());
}
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 += "*";
@@ -396,70 +437,141 @@ 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;
- BitsInit *New = new BitsInit(getNumBits());
- for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
- Init *B;
- Init *CurBit = getBit(i);
+ SmallVector<const Init *, 16> Bits(getNumBits());
+
+ for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
+ const Init *B;
+ const Init *CurBit = getBit(i);
do {
B = CurBit;
CurBit = CurBit->resolveReferences(R, RV);
Changed |= B != CurBit;
} while (B != CurBit);
- New->setBit(i, CurBit);
+ Bits[i] = CurBit;
}
if (Changed)
- return New;
- delete New;
+ return BitsInit::Create(Bits.begin(), Bits.end());
+
return this;
}
+const IntInit *IntInit::Create(int64_t V) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initInt);
+ ID.AddInteger(V);
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const IntInit *>(I);
+
+ IntInit *I = InitAllocator.Allocate<IntInit>();
+ new (I) IntInit(ID, V);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
std::string IntInit::getAsString() const {
return itostr(Value);
}
-Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
- BitsInit *BI = new BitsInit(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) {
- delete BI;
+ if (Bits[i] >= 64)
return 0;
- }
- BI->setBit(i, new BitInit(Value & (INT64_C(1) << Bits[i])));
+
+ NewBits[i] = BitInit::Create(Value & (INT64_C(1) << Bits[i]));
}
- return BI;
+
+ return BitsInit::Create(NewBits.begin(), NewBits.end());
}
-Init *ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
- std::vector<Init*> Vals;
+const StringInit *StringInit::Create(const std::string &V) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initString);
+ ID.AddString(V);
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const StringInit *>(I);
+
+ StringInit *I = InitAllocator.Allocate<StringInit>();
+ new (I) StringInit(ID, V);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
+const CodeInit *CodeInit::Create(const std::string &V) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initCode);
+ ID.AddString(V);
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const CodeInit *>(I);
+
+ CodeInit *I = InitAllocator.Allocate<CodeInit>();
+ new (I) CodeInit(ID, V);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
+const ListInit *ListInit::Create(std::vector<const Init *> &Vs, RecTy *EltTy) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initList);
+ ID.AddString(EltTy->getAsString());
+
+ for (std::vector<const Init *>::iterator i = Vs.begin(), iend = Vs.end();
+ i != iend;
+ ++i) {
+ ID.AddPointer(*i);
+ }
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const ListInit *>(I);
+
+ ListInit *I = InitAllocator.Allocate<ListInit>();
+ new (I) ListInit(ID, Vs, EltTy);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
+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;
Vals.push_back(getElement(Elements[i]));
}
- return new ListInit(Vals, getType());
+ return ListInit::Create(Vals, getType());
}
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;
@@ -470,20 +582,25 @@ Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) {
}
if (Changed)
- return new ListInit(Resolved, getType());
+ return ListInit::Create(Resolved, getType());
+
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;
}
@@ -496,12 +613,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);
}
@@ -510,12 +627,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);
}
@@ -524,22 +641,39 @@ Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV,
return 0;
}
-Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
+const UnOpInit *UnOpInit::Create(UnaryOp opc, const Init *lhs, RecTy *Type) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initUnOp);
+ ID.AddInteger(opc);
+ ID.AddString(Type->getAsString());
+ ID.AddPointer(lhs);
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const UnOpInit *>(I);
+
+ UnOpInit *I = InitAllocator.Allocate<UnOpInit>();
+ new (I) UnOpInit(ID, opc, lhs, Type);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
+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());
+ return StringInit::Create(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();
@@ -548,7 +682,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
if (const RecordVal *RV = CurRec->getValue(Name)) {
if (RV->getType() != getType())
throw "type mismatch in cast";
- return new VarInit(Name, RV->getType());
+ return VarInit::Create(Name, RV->getType());
}
std::string TemplateArgName = CurRec->getName()+":"+Name;
@@ -559,7 +693,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
if (RV->getType() != getType())
throw "type mismatch in cast";
- return new VarInit(TemplateArgName, RV->getType());
+ return VarInit::Create(TemplateArgName, RV->getType());
}
}
@@ -572,12 +706,12 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
if (RV->getType() != getType())
throw "type mismatch in cast";
- return new VarInit(MCName, RV->getType());
+ return VarInit::Create(MCName, RV->getType());
}
}
if (Record *D = (CurRec->getRecords()).getDef(Name))
- return new DefInit(D);
+ return DefInit::Create(D);
throw TGError(CurRec->getLoc(), "Undefined reference:'" + Name + "'\n");
}
@@ -585,7 +719,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");
@@ -596,33 +730,33 @@ 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");
return 0;
}
- ListInit *Result = new ListInit(LHSl->begin()+1, LHSl->end(),
- LHSl->getType());
+ const ListInit *Result = ListInit::Create(LHSl->begin()+1, LHSl->end(),
+ 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);
+ return IntInit::Create(1);
} else {
- return new IntInit(0);
+ return IntInit::Create(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);
+ return IntInit::Create(1);
} else {
- return new IntInit(0);
+ return IntInit::Create(0);
}
}
@@ -632,11 +766,12 @@ 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);
+ return (UnOpInit::Create(getOpcode(), lhs, getType()))->Fold(&R, 0);
return Fold(&R, 0);
}
@@ -651,18 +786,37 @@ std::string UnOpInit::getAsString() const {
return Result + "(" + LHS->getAsString() + ")";
}
-Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
+const BinOpInit *BinOpInit::Create(BinaryOp opc, const Init *lhs,
+ const Init *rhs, RecTy *Type) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initBinOp);
+ ID.AddInteger(opc);
+ ID.AddString(Type->getAsString());
+ ID.AddPointer(lhs);
+ ID.AddPointer(rhs);
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const BinOpInit *>(I);
+
+ BinOpInit *I = InitAllocator.Allocate<BinOpInit>();
+ new (I) BinOpInit(ID, opc, lhs, rhs, Type);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
+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));
@@ -672,42 +826,42 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
Args.push_back(RHSs->getArg(i));
ArgNames.push_back(RHSs->getArgName(i));
}
- return new DagInit(LHSs->getOperator(), "", Args, ArgNames);
+ return DagInit::Create(LHSs->getOperator(), "", Args, ArgNames);
}
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());
+ return StringInit::Create(LHSs->getValue() + RHSs->getValue());
break;
}
case EQ: {
// try to fold eq comparison for 'bit' and 'int', otherwise fallback
// to string objects.
- IntInit* L =
- dynamic_cast<IntInit*>(LHS->convertInitializerTo(new IntRecTy()));
- IntInit* R =
- dynamic_cast<IntInit*>(RHS->convertInitializerTo(new IntRecTy()));
+ const IntInit* L =
+ dynamic_cast<const IntInit*>(LHS->convertInitializerTo(new IntRecTy()));
+ const IntInit* R =
+ dynamic_cast<const IntInit*>(RHS->convertInitializerTo(new IntRecTy()));
if (L && R)
- return new IntInit(L->getValue() == R->getValue());
+ return IntInit::Create(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)
- return new IntInit(LHSs->getValue() == RHSs->getValue());
+ return IntInit::Create(LHSs->getValue() == RHSs->getValue());
break;
}
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;
@@ -717,7 +871,7 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
case SRA: Result = LHSv >> RHSv; break;
case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break;
}
- return new IntInit(Result);
+ return IntInit::Create(Result);
}
break;
}
@@ -725,12 +879,13 @@ 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);
+ return (BinOpInit::Create(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0);
return Fold(&R, 0);
}
@@ -747,20 +902,43 @@ 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);
+const TernOpInit *TernOpInit::Create(TernaryOp opc, const Init *lhs,
+ const Init *mhs, const Init *rhs,
+ RecTy *Type) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initTernOp);
+ ID.AddInteger(opc);
+ ID.AddString(Type->getAsString());
+ ID.AddPointer(lhs);
+ ID.AddPointer(mhs);
+ ID.AddPointer(rhs);
-static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
- RecTy *Type, Record *CurRec,
- MultiClass *CurMultiClass) {
- std::vector<Init *> NewOperands;
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const TernOpInit *>(I);
+
+ TernOpInit *I = InitAllocator.Allocate<TernOpInit>();
+ new (I) TernOpInit(ID, opc, lhs, mhs, rhs, Type);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
- TypedInit *TArg = dynamic_cast<TypedInit*>(Arg);
+static const Init *ForeachHelper(const Init *LHS, const Init *MHS,
+ const Init *RHS, RecTy *Type,
+ Record *CurRec, MultiClass *CurMultiClass);
+
+static const Init *EvaluateOperation(const OpInit *RHSo, const Init *LHS,
+ const Init *Arg, RecTy *Type,
+ Record *CurRec,
+ MultiClass *CurMultiClass) {
+ std::vector<const Init *> NewOperands;
+
+ 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,
- CurRec, CurMultiClass);
+ const Init *Result = ForeachHelper(LHS, Arg, RHSo, Type,
+ CurRec, CurMultiClass);
if (Result != 0) {
return Result;
} else {
@@ -768,18 +946,21 @@ static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
}
}
+ bool change = false;
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,
- Type, CurRec, CurMultiClass);
+ const Init *Result = EvaluateOperation(RHSoo, LHS, Arg,
+ Type, CurRec, CurMultiClass);
if (Result != 0) {
+ change = true;
NewOperands.push_back(Result);
} else {
NewOperands.push_back(Arg);
}
} else if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) {
+ change = true;
NewOperands.push_back(Arg);
} else {
NewOperands.push_back(RHSo->getOperand(i));
@@ -787,30 +968,31 @@ 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);
- if (NewVal != NewOp) {
- delete NewOp;
+ const OpInit *NewOp = RHSo->clone(NewOperands);
+ const Init *NewVal = NewOp->Fold(CurRec, CurMultiClass);
+
+ if (change) {
return NewVal;
}
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");
@@ -818,23 +1000,23 @@ 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,
- Type, CurRec, CurMultiClass);
+ 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,
- CurRec, CurMultiClass);
+ const Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type,
+ CurRec, CurMultiClass);
if (Result != 0) {
Arg = Result;
}
@@ -843,17 +1025,17 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
args.push_back(std::make_pair(Arg, ArgName));
}
- return new DagInit(Val, "", args);
+ return DagInit::Create(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 (ListInit::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
@@ -865,34 +1047,33 @@ 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;
}
}
- return new ListInit(NewList, MHSl->getType());
+ return ListInit::Create(NewList, MHSl->getType());
}
}
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)
@@ -902,14 +1083,14 @@ Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
if (LHSd->getAsString() == RHSd->getAsString()) {
Val = MHSd->getDef();
}
- return new DefInit(Val);
+ return DefInit::Create(Val);
}
if (RHSv) {
std::string Val = RHSv->getName();
if (LHSv->getAsString() == RHSv->getAsString()) {
Val = MHSv->getName();
}
- return new VarInit(Val, getType());
+ return VarInit::Create(Val, getType());
}
if (RHSs) {
std::string Val = RHSs->getValue();
@@ -924,14 +1105,14 @@ Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
idx = found + MHSs->getValue().size();
} while (found != std::string::npos);
- return new StringInit(Val);
+ return StringInit::Create(Val);
}
}
break;
}
case FOREACH: {
- Init *Result = ForeachHelper(LHS, MHS, RHS, getType(),
+ const Init *Result = ForeachHelper(LHS, MHS, RHS, getType(),
CurRec, CurMultiClass);
if (Result != 0) {
return Result;
@@ -940,9 +1121,9 @@ Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
}
case IF: {
- IntInit *LHSi = dynamic_cast<IntInit*>(LHS);
- if (Init *I = LHS->convertInitializerTo(new IntRecTy()))
- LHSi = dynamic_cast<IntInit*>(I);
+ const IntInit *LHSi = dynamic_cast<const IntInit*>(LHS);
+ if (const Init *I = LHS->convertInitializerTo(new IntRecTy()))
+ LHSi = dynamic_cast<const IntInit*>(I);
if (LHSi) {
if (LHSi->getValue()) {
return MHS;
@@ -957,32 +1138,35 @@ 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(new IntRecTy()))
- Value = dynamic_cast<IntInit*>(I);
+ const IntInit *Value = dynamic_cast<const IntInit*>(lhs);
+ if (const Init *I = lhs->convertInitializerTo(new IntRecTy()))
+ Value = dynamic_cast<const IntInit*>(I);
if (Value != 0) {
// Short-circuit
if (Value->getValue()) {
- Init *mhs = MHS->resolveReferences(R, RV);
- return (new TernOpInit(getOpcode(), lhs, mhs,
- RHS, getType()))->Fold(&R, 0);
+ const Init *mhs = MHS->resolveReferences(R, RV);
+ return (TernOpInit::Create(getOpcode(), lhs, mhs,
+ RHS, getType()))->Fold(&R, 0);
} else {
- Init *rhs = RHS->resolveReferences(R, RV);
- return (new TernOpInit(getOpcode(), lhs, MHS,
- rhs, getType()))->Fold(&R, 0);
+ const Init *rhs = RHS->resolveReferences(R, RV);
+ return (TernOpInit::Create(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);
+ return (TernOpInit::Create(getOpcode(), lhs, mhs, rhs, getType()))->
+ Fold(&R, 0);
return Fold(&R, 0);
}
@@ -1008,79 +1192,97 @@ 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();
- BitsInit *BI = new BitsInit(Bits.size());
+ SmallVector<const Init *, 16> NewBits(Bits.size());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= NumBits) {
- delete BI;
return 0;
}
- BI->setBit(i, new VarBitInit(this, Bits[i]));
+ NewBits[i] = VarBitInit::Create(this, Bits[i]);
}
- return BI;
+ return BitsInit::Create(NewBits.begin(), NewBits.end());
}
-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]);
+ return VarListElementInit::Create(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]));
- return new ListInit(ListInits, T);
+ ListInits.push_back(VarListElementInit::Create(this, Elements[i]));
+ return ListInit::Create(ListInits, T);
}
-Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV,
- unsigned Bit) {
+const VarInit *VarInit::Create(const std::string &VN, RecTy *T) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initVar);
+ ID.AddString(VN);
+ ID.AddString(T->getAsString());
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const VarInit *>(I);
+
+ VarInit *I = InitAllocator.Allocate<VarInit>();
+ new (I) VarInit(ID, VN, T);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
+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);
+ return VarListElementInit::Create(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;
}
@@ -1093,15 +1295,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;
@@ -1114,56 +1316,112 @@ 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;
}
+const VarBitInit *VarBitInit::Create(const TypedInit *T, unsigned B) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initVarBit);
+ ID.AddPointer(T);
+ ID.AddInteger(B);
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const VarBitInit *>(I);
+
+ VarBitInit *I = InitAllocator.Allocate<VarBitInit>();
+ new (I) VarBitInit(ID, T, B);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
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;
}
+const VarListElementInit *VarListElementInit::Create(const TypedInit *T,
+ unsigned E) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initVarListElement);
+ ID.AddPointer(T);
+ ID.AddInteger(E);
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const VarListElementInit *>(I);
+
+ VarListElementInit *I = InitAllocator.Allocate<VarListElementInit>();
+ new (I) VarListElementInit(ID, T, E);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
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,
- getElementNum()))
+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;
}
+const DefInit *DefInit::Create(Record *D) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initDef);
+ ID.AddString(D->getName());
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const DefInit *>(I);
+
+ DefInit *I = InitAllocator.Allocate<DefInit>();
+ new (I) DefInit(ID, D);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
RecTy *DefInit::getFieldType(const std::string &FieldName) const {
if (const RecordVal *RV = Def->getValue(FieldName))
return RV->getType();
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();
}
@@ -1172,59 +1430,134 @@ 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 FieldInit *FieldInit::Create(const Init *R, const std::string &FN) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initField);
+ ID.AddPointer(R);
+ ID.AddString(FN);
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const FieldInit *>(I);
+
+ FieldInit *I = InitAllocator.Allocate<FieldInit>();
+ new (I) FieldInit(ID, R, FN);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
+const Init *FieldInit::resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const {
+ if (const Init *BitsVal = Rec->getFieldInit(R, RV, FieldName))
+ if (const BitsInit *BI = dynamic_cast<const BitsInit*>(BitsVal)) {
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;
}
if (NewRec != Rec) {
- return new FieldInit(NewRec, FieldName);
+ return FieldInit::Create(NewRec, FieldName);
}
return this;
}
-Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) {
- std::vector<Init*> NewArgs;
+const DagInit *
+DagInit::Create(const Init *V, const std::string &VN,
+ const std::vector<std::pair<const Init*, std::string> > &args) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initDag);
+ ID.AddPointer(V);
+ ID.AddString(VN);
+
+ for (std::vector<std::pair<const Init*, std::string> >::const_iterator a
+ = args.begin(),
+ aend = args.end();
+ a != aend;
+ ++a) {
+ ID.AddPointer(a->first);
+ ID.AddString(a->second);
+ }
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const DagInit *>(I);
+
+ DagInit *I = InitAllocator.Allocate<DagInit>();
+ new (I) DagInit(ID, V, VN, args);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
+const DagInit *
+DagInit::Create(const Init *V, const std::string &VN,
+ const std::vector<const Init *> &args,
+ const std::vector<std::string> &argNames) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initDag);
+ ID.AddPointer(V);
+ ID.AddString(VN);
+
+ std::vector<std::string>::const_iterator s = argNames.begin();
+ for (std::vector<const Init*>::const_iterator a
+ = args.begin(),
+ aend = args.end();
+ a != aend;
+ ++a, ++s) {
+ ID.AddPointer(*a);
+ ID.AddString(*s);
+ }
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const DagInit *>(I);
+
+ DagInit *I = InitAllocator.Allocate<DagInit>();
+ new (I) DagInit(ID, V, VN, args, argNames);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+}
+
+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);
+ return DagInit::Create(Op, ValName, NewArgs, ArgNames);
return this;
}
@@ -1252,7 +1585,7 @@ std::string DagInit::getAsString() const {
RecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P)
: Name(N), Ty(T), Prefix(P) {
- Value = Ty->convertValue(new UnsetInit());
+ Value = Ty->convertValue(UnsetInit::Create());
assert(Value && "Cannot create unset value for current type!");
}
@@ -1287,7 +1620,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));
}
}
@@ -1332,7 +1665,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 `" +
@@ -1361,13 +1694,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!";
@@ -1377,13 +1710,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!";
@@ -1395,10 +1728,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() +
@@ -1418,7 +1751,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!";
@@ -1430,10 +1763,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() +
@@ -1449,10 +1782,11 @@ 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() +
@@ -1472,7 +1806,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!";
@@ -1488,7 +1822,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!";
@@ -1498,13 +1832,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 f24f5e66fa..52b46eaa89 100644
--- a/utils/TableGen/Record.h
+++ b/utils/TableGen/Record.h
@@ -15,6 +15,8 @@
#ifndef RECORD_H
#define RECORD_H
+#include "llvm/ADT/FoldingSet.h"
+#include "llvm/Support/Allocator.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/raw_ostream.h"
@@ -75,31 +77,31 @@ struct RecTy {
virtual bool typeIsConvertibleTo(const RecTy *RHS) const = 0;
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.
@@ -125,22 +127,38 @@ inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) {
///
class BitRecTy : public RecTy {
public:
- 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"; }
@@ -169,22 +187,32 @@ 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;
@@ -209,22 +237,36 @@ public:
///
class IntRecTy : public RecTy {
public:
- 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"; }
@@ -247,23 +289,33 @@ public:
///
class StringRecTy : public RecTy {
public:
- 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"; }
@@ -293,22 +345,34 @@ public:
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;
@@ -332,22 +396,36 @@ public:
///
class CodeRecTy : public RecTy {
public:
- 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"; }
@@ -368,22 +446,32 @@ public:
///
class DagRecTy : public RecTy {
public:
- 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"; }
@@ -412,22 +500,34 @@ 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;
@@ -453,9 +553,43 @@ RecTy *resolveTypes(RecTy *T1, RecTy *T2);
// Initializer Classes
//===----------------------------------------------------------------------===//
-struct Init {
+class Init : public FastFoldingSetNode {
+ Init(const Init &); // Do not define.
+ Init &operator=(const Init &); // Do not define.
+
+protected:
+ Init(const FoldingSetNodeID &ID) : FastFoldingSetNode(ID) {}
+
+ static FoldingSet<Init> UniqueInits;
+ static BumpPtrAllocator InitAllocator;
+
+ enum Type {
+ initUnset,
+ initBit,
+ initBits,
+ initInt,
+ initString,
+ initCode,
+ initList,
+ initUnOp,
+ initBinOp,
+ initTernOp,
+ initQuadOp,
+ initVar,
+ initVarBit,
+ initVarListElement,
+ initDef,
+ initField,
+ initDag
+ };
+
+public:
virtual ~Init() {}
+ static void ReleaseMemory() {
+ InitAllocator.Reset();
+ }
+
/// isComplete - This virtual method should be overridden by values that may
/// not be completely specified yet.
virtual bool isComplete() const { return true; }
@@ -474,14 +608,15 @@ struct Init {
/// 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;
}
@@ -490,7 +625,8 @@ struct Init {
/// 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;
}
@@ -504,8 +640,8 @@ struct Init {
/// 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;
}
@@ -514,7 +650,8 @@ struct Init {
/// 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;
}
};
@@ -528,13 +665,20 @@ inline raw_ostream &operator<<(raw_ostream &OS, const Init &I) {
///
class TypedInit : public Init {
RecTy *Ty;
-public:
- explicit TypedInit(RecTy *T) : Ty(T) {}
+ TypedInit(const TypedInit &Other); // Do not define.
+ TypedInit &operator=(const TypedInit &Other); // Do not define.
+
+protected:
+ explicit TypedInit(const FoldingSetNodeID &ID, RecTy *T) : Init(ID), Ty(T) {}
+
+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
@@ -546,22 +690,29 @@ 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;
};
/// UnsetInit - ? - Represents an uninitialized value
///
class UnsetInit : public Init {
+ UnsetInit(const FoldingSetNodeID &ID) : Init(ID) {}
+ UnsetInit(const UnsetInit &); // Do not define.
+ UnsetInit &operator=(const UnsetInit &Other); // Do not define.
+
public:
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ static const UnsetInit *Create();
+
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
@@ -574,12 +725,17 @@ public:
///
class BitInit : public Init {
bool Value;
+
+ explicit BitInit(const FoldingSetNodeID &ID, bool V) : Init(ID), Value(V) {}
+ BitInit(const BitInit &Other); // Do not define.
+ BitInit &operator=(BitInit &Other); // Do not define.
+
public:
- explicit BitInit(bool V) : Value(V) {}
+ static const BitInit *Create(bool V);
bool getValue() const { return Value; }
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
@@ -590,26 +746,56 @@ 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;
+
+ BitsInit(const FoldingSetNodeID &ID, unsigned Size)
+ : Init(ID), Bits(Size) {}
+
+ template<typename InputIterator>
+ BitsInit(const FoldingSetNodeID &ID, InputIterator start, InputIterator end)
+ : Init(ID), Bits(start, end) {}
+
+ BitsInit(const BitsInit &Other); // Do not define.
+ BitsInit &operator=(const BitsInit &Other); // Do not define.
+
public:
- explicit BitsInit(unsigned Size) : Bits(Size) {}
+ template<typename InputIterator>
+ static const BitsInit *Create(InputIterator Start, InputIterator End) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initBits);
+ ID.AddInteger(std::distance(Start, End));
+
+ InputIterator S = Start;
+ while (S != End)
+ ID.AddPointer(*S++);
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const BitsInit *>(I);
+
+ BitsInit *I = InitAllocator.Allocate<BitsInit>();
+ new (I) BitsInit(ID, Start, End);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+ }
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];
}
- void setBit(unsigned Bit, Init *V) {
+ void setBit(unsigned Bit, const Init *V) {
assert(Bit < Bits.size() && "Bit index out of range!");
assert(Bits[Bit] == 0 && "Bit already set!");
Bits[Bit] = V;
}
- 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)
@@ -623,7 +809,8 @@ public:
}
virtual std::string getAsString() const;
- virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+ virtual const Init *resolveReferences(Record &R,
+ const RecordVal *RV) const;
};
@@ -631,15 +818,23 @@ public:
///
class IntInit : public TypedInit {
int64_t Value;
+
+ explicit IntInit(const FoldingSetNodeID &ID, int64_t V)
+ : TypedInit(ID, new IntRecTy), Value(V) {}
+
+ IntInit(const IntInit &Other); // Do not define.
+ IntInit &operator=(const IntInit &Other); // Do note define.
+
public:
- explicit IntInit(int64_t V) : TypedInit(new IntRecTy), Value(V) {}
+ static const IntInit *Create(int64_t V);
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;
@@ -647,8 +842,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;
}
@@ -656,8 +851,9 @@ 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;
}
@@ -668,13 +864,19 @@ public:
///
class StringInit : public TypedInit {
std::string Value;
+
+ explicit StringInit(const FoldingSetNodeID &ID, const std::string &V)
+ : TypedInit(ID, new StringRecTy), Value(V) {}
+
+ StringInit(const StringInit &Other); // Do not define.
+ StringInit &operator=(const StringInit &Other); // Do not define.
+
public:
- explicit StringInit(const std::string &V)
- : TypedInit(new StringRecTy), Value(V) {}
+ static const StringInit *Create(const std::string &V);
const std::string &getValue() const { return Value; }
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
@@ -684,8 +886,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;
}
@@ -693,8 +895,9 @@ 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;
}
@@ -704,12 +907,19 @@ public:
///
class CodeInit : public Init {
std::string Value;
+
+ explicit CodeInit(const FoldingSetNodeID &ID, const std::string &V)
+ : Init(ID), Value(V) {}
+
+ CodeInit(const CodeInit &Other); // Do not define.
+ CodeInit &operator=(const CodeInit &Other); // Do not define.
+
public:
- explicit CodeInit(const std::string &V) : Value(V) {}
+ static const CodeInit *Create(const std::string &V);
const std::string &getValue() const { return Value; }
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
@@ -719,29 +929,61 @@ 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*>::iterator iterator;
- 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)
- : TypedInit(new ListRecTy(EltTy)) {
+private:
+ ListInit(const FoldingSetNodeID &ID, std::vector<const Init*> &Vs,
+ RecTy *EltTy)
+ : TypedInit(ID, new ListRecTy(EltTy)) {
Values.swap(Vs);
}
- explicit ListInit(iterator Start, iterator End, RecTy *EltTy)
- : TypedInit(new ListRecTy(EltTy)), Values(Start, End) {}
+
+ template<typename InputIterator>
+ ListInit(const FoldingSetNodeID &ID, InputIterator Start, InputIterator End,
+ RecTy *EltTy)
+ : TypedInit(ID, new ListRecTy(EltTy)), Values(Start, End) {}
+
+ ListInit(const ListInit &Other); // Do not define.
+ ListInit &operator=(const ListInit &Other); // Do not define.
+
+public:
+ static const ListInit *Create(std::vector<const Init*> &Vs, RecTy *EltTy);
+
+ template<typename InputIterator>
+ static const ListInit *Create(InputIterator Start, InputIterator End,
+ RecTy *EltTy) {
+ FoldingSetNodeID ID;
+ ID.AddInteger(initList);
+ ID.AddString(EltTy->getAsString());
+
+ InputIterator S = Start;
+ while (S != End)
+ ID.AddPointer(*S++);
+
+ void *IP = 0;
+ if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
+ return static_cast<const ListInit *>(I);
+
+ ListInit *I = InitAllocator.Allocate<ListInit>();
+ new (I) ListInit(ID, Start, End, EltTy);
+ UniqueInits.InsertNode(I, IP);
+ return I;
+ }
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);
}
@@ -750,13 +992,12 @@ 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;
- inline iterator begin() { return Values.begin(); }
inline const_iterator begin() const { return Values.begin(); }
- inline iterator end () { return Values.end(); }
inline const_iterator end () const { return Values.end(); }
inline size_t size () const { return Values.size(); }
@@ -766,8 +1007,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;
}
@@ -775,35 +1016,42 @@ 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;
};
/// OpInit - Base class for operators
///
class OpInit : public TypedInit {
-public:
- OpInit(RecTy *Type) : TypedInit(Type) {}
+ OpInit(const OpInit &Other); // Do not define.
+ OpInit &operator=(OpInit &Other); // Do not define.
+
+protected:
+ explicit OpInit(const FoldingSetNodeID &ID, RecTy *Type)
+ : TypedInit(ID, Type) {}
+public:
// 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;
};
@@ -814,33 +1062,40 @@ public:
enum UnaryOp { CAST, HEAD, TAIL, EMPTY };
private:
UnaryOp Opc;
- Init *LHS;
+ const Init *LHS;
+
+ UnOpInit(const FoldingSetNodeID &ID, UnaryOp opc, const Init *lhs,
+ RecTy *Type)
+ : OpInit(ID, Type), Opc(opc), LHS(lhs) {}
+
+ UnOpInit(const UnOpInit &Other); // Do not define.
+ UnOpInit &operator=(const UnOpInit &Other); // Do not define.
+
public:
- UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type) :
- OpInit(Type), Opc(opc), LHS(lhs) {
- }
+ static const UnOpInit *Create(UnaryOp opc, const Init *lhs, RecTy *Type);
// 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());
+ return UnOpInit::Create(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;
};
@@ -852,21 +1107,28 @@ public:
enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, EQ };
private:
BinaryOp Opc;
- Init *LHS, *RHS;
+ const Init *LHS, *RHS;
+
+ BinOpInit(const FoldingSetNodeID &ID, BinaryOp opc, const Init *lhs,
+ const Init *rhs, RecTy *Type) :
+ OpInit(ID, Type), Opc(opc), LHS(lhs), RHS(rhs) {}
+
+ BinOpInit(const BinOpInit &Other); // Do not define.
+ BinOpInit &operator=(const BinOpInit &Other); // Do not define.
+
public:
- BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
- OpInit(Type), Opc(opc), LHS(lhs), RHS(rhs) {
- }
+ static const BinOpInit *Create(BinaryOp opc, const Init *lhs, const Init *rhs,
+ RecTy *Type);
// 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());
+ return BinOpInit::Create(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();
@@ -876,14 +1138,15 @@ 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;
};
@@ -895,22 +1158,30 @@ public:
enum TernaryOp { SUBST, FOREACH, IF };
private:
TernaryOp Opc;
- Init *LHS, *MHS, *RHS;
+ const Init *LHS, *MHS, *RHS;
+
+ TernOpInit(const FoldingSetNodeID &ID, TernaryOp opc, const Init *lhs,
+ const Init *mhs, const Init *rhs, RecTy *Type) :
+ OpInit(ID, Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) {}
+
+ TernOpInit(const TernOpInit &Other); // Do not define.
+ TernOpInit &operator=(const TernOpInit &Other); // Do not define.
+
public:
- TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs, RecTy *Type) :
- OpInit(Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) {
- }
+ static const TernOpInit *Create(TernaryOp opc, const Init *lhs,
+ const Init *mhs, const Init *rhs,
+ RecTy *Type);
// 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],
- getType());
+ return TernOpInit::Create(getOpcode(), Operands[0], Operands[1],
+ Operands[2], getType());
}
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) {
@@ -923,17 +1194,18 @@ 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;
};
@@ -943,23 +1215,31 @@ public:
///
class VarInit : public TypedInit {
std::string VarName;
+
+ explicit VarInit(const FoldingSetNodeID &ID, const std::string &VN, RecTy *T)
+ : TypedInit(ID, T), VarName(VN) {}
+
+ VarInit(const VarInit &Other); // Do not define.
+ VarInit &operator=(const VarInit &Other); // Do not define.
+
public:
- explicit VarInit(const std::string &VN, RecTy *T)
- : TypedInit(T), VarName(VN) {}
+ static const VarInit *Create(const std::string &VN, RecTy *T);
+ static const VarInit *Create(const Init *VN, RecTy *T);
- 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,
+ 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
@@ -967,7 +1247,8 @@ 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 { return VarName; }
};
@@ -976,76 +1257,101 @@ 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 FoldingSetNodeID &ID, const TypedInit *T, unsigned B)
+ : Init(ID), 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) {
+ VarBitInit(const VarBitInit &Other); // Do not define.
+ VarBitInit &operator=(const VarBitInit &Other); // Do not define.
+
+public:
+ static const VarBitInit *Create(const TypedInit *T, unsigned B);
+
+ 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)
- : TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()),
+
+ VarListElementInit(const FoldingSetNodeID &ID, const TypedInit *T, unsigned E)
+ : TypedInit(ID, 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) {
+ VarListElementInit(const VarListElementInit &Other); // Do not define.
+ VarListElementInit &operator=(const VarListElementInit &Other); // Do
+ // not
+ // define.
+
+public:
+ static const VarListElementInit *Create(const TypedInit *T, unsigned E);
+
+ 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
///
class DefInit : public TypedInit {
Record *Def;
+
+ explicit DefInit(const FoldingSetNodeID &ID, Record *D)
+ : TypedInit(ID, new RecordRecTy(D)), Def(D) {}
+
+ DefInit(const DefInit &Other); // Do not define.
+ DefInit &operator=(const DefInit &Other); // Do not define.
+
public:
- explicit DefInit(Record *D) : TypedInit(new RecordRecTy(D)), Def(D) {}
+ static const DefInit *Create(Record *D);
- 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) const;
virtual RecTy *getFieldType(const std::string &FieldName) const;
- virtual Init *getFieldInit(Record &R, const RecordVal *RV,
+ virtual const Init *getFieldInit(Record &R, const RecordVal *RV,
const std::string &FieldName) const;
virtual std::string getAsString() const;
@@ -1054,8 +1360,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;
}
@@ -1063,8 +1369,9 @@ 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;
}
@@ -1074,24 +1381,33 @@ 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)
- : TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) {
+
+ FieldInit(const FoldingSetNodeID &ID, const Init *R, const std::string &FN)
+ : TypedInit(ID, R->getFieldType(FN)), Rec(R), FieldName(FN) {
assert(getType() && "FieldInit with non-record type!");
}
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ FieldInit(const FieldInit &Other); // Do not define.
+ FieldInit &operator=(const FieldInit &Other); // Do not define.
+
+public:
+ static const FieldInit *Create(const Init *R, const std::string &FN);
+ static const FieldInit *Create(const Init *R, const Init *FN);
+
+ 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;
@@ -1103,14 +1419,14 @@ 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)
- : TypedInit(new DagRecTy), Val(V), ValName(VN) {
+
+ DagInit(const FoldingSetNodeID &ID, const Init *V, const std::string &VN,
+ const std::vector<std::pair<const Init*, std::string> > &args)
+ : TypedInit(ID, new DagRecTy), Val(V), ValName(VN) {
Args.reserve(args.size());
ArgNames.reserve(args.size());
for (unsigned i = 0, e = args.size(); i != e; ++i) {
@@ -1118,21 +1434,33 @@ public:
ArgNames.push_back(args[i].second);
}
}
- DagInit(Init *V, std::string VN, const std::vector<Init*> &args,
+ DagInit(const FoldingSetNodeID &ID, const Init *V, const std::string &VN,
+ const std::vector<const Init*> &args,
const std::vector<std::string> &argNames)
- : TypedInit(new DagRecTy), Val(V), ValName(VN), Args(args),
+ : TypedInit(ID, new DagRecTy), Val(V), ValName(VN), Args(args),
ArgNames(argNames) { }
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ DagInit(const DagInit &Other); // Do not define.
+ DagInit &operator=(const DagInit &Other); // Do not define.
+
+public:
+ static const DagInit *Create(const Init *V, const std::string &VN,
+ const std::vector<
+ std::pair<const Init*, std::string> > &args);
+ static const DagInit *Create(const Init *V, const std::string &VN,
+ const std::vector<const Init*> &args,
+ const std::vector<std::string> &argNames);
+
+ 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];
}
@@ -1141,17 +1469,18 @@ public:
return ArgNames[Num];
}
- void setArg(unsigned Num, Init *I) {
+ void setArg(unsigned Num, const Init *I) {
assert(Num < Args.size() && "Arg number out of range!");
Args[Num] = I;
}
- 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*>::iterator arg_iterator;
- typedef std::vector<Init*>::const_iterator const_arg_iterator;
+ typedef std::vector<const Init*>::iterator arg_iterator;
+ typedef std::vector<const Init*>::const_iterator const_arg_iterator;
typedef std::vector<std::string>::iterator name_iterator;
typedef std::vector<std::string>::const_iterator const_name_iterator;
@@ -1171,14 +1500,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;
}
@@ -1192,7 +1522,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);
@@ -1200,9 +1530,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;
@@ -1336,7 +1666,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
@@ -1348,13 +1678,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
@@ -1396,7 +1726,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 abb862445d..06352a5f69 100644
--- a/utils/TableGen/RegisterInfoEmitter.cpp
+++ b/utils/TableGen/RegisterInfoEmitter.cpp
@@ -722,7 +722,7 @@ RegisterInfoEmitter::runTargetDesc(raw_ostream &OS, CodeGenTarget &Target,
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..a888bbc724 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,26 @@ 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 +168,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 +223,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 +233,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 e37a76ee68..e2309b2af6 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 59097f986f..3e48e64537 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,37 +101,37 @@ 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(new BitsRecTy(BitList.size()));
+ const Init *BI = V->convertInitializerTo(new BitsRecTy(BitList.size()));
if (BI == 0) {
V->convertInitializerTo(new BitsRecTy(BitList.size()));
return Error(Loc, "Initializer is not compatible with bit range");
}
// We should have a BitsInit type now.
- BitsInit *BInit = dynamic_cast<BitsInit*>(BI);
+ const BitsInit *BInit = dynamic_cast<const BitsInit*>(BI);
assert(BInit != 0);
- BitsInit *NewVal = new BitsInit(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) {
unsigned Bit = BitList[i];
- if (NewVal->getBit(Bit))
+ if (NewBits[Bit])
return Error(Loc, "Cannot set bit #" + utostr(Bit) + " of value '" +
ValName + "' more than once");
- NewVal->setBit(Bit, BInit->getBit(i));
+ NewBits[Bit] = BInit->getBit(i);
}
for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
- if (NewVal->getBit(i) == 0)
- NewVal->setBit(i, CurVal->getBit(i));
+ if (NewBits[i] == 0)
+ NewBits[i] = CurVal->getBit(i);
- V = NewVal;
+ V = BitsInit::Create(NewBits.begin(), NewBits.end());
}
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,17 +643,17 @@ 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))
- return new VarInit(Name, RV->getType());
+ return VarInit::Create(Name, RV->getType());
std::string TemplateArgName = CurRec->getName()+":"+Name;
if (CurRec->isTemplateArg(TemplateArgName)) {
const RecordVal *RV = CurRec->getValue(TemplateArgName);
assert(RV && "Template arg doesn't exist??");
- return new VarInit(TemplateArgName, RV->getType());
+ return VarInit::Create(TemplateArgName, RV->getType());
}
}
@@ -662,12 +662,12 @@ Init *TGParser::ParseIDValue(Record *CurRec,
if (CurMultiClass->Rec.isTemplateArg(MCName)) {
const RecordVal *RV = CurMultiClass->Rec.getValue(MCName);
assert(RV && "Template arg doesn't exist??");
- return new VarInit(MCName, RV->getType());
+ return VarInit::Create(MCName, RV->getType());
}
}
if (Record *D = Records.getDef(Name))
- return new DefInit(D);
+ return DefInit::Create(D);
Error(NameLoc, "Variable not defined: '" + Name + "'");
return 0;
@@ -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;
@@ -790,7 +790,7 @@ Init *TGParser::ParseOperation(Record *CurRec) {
return 0;
}
Lex.Lex(); // eat the ')'
- return (new UnOpInit(Code, LHS, Type))->Fold(CurRec, CurMultiClass);
+ return (UnOpInit::Create(Code, LHS, Type))->Fold(CurRec, CurMultiClass);
}
case tgtok::XConcat:
@@ -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,15 +847,15 @@ Init *TGParser::ParseOperation(Record *CurRec) {
// shorthand for nesting them.
if (Code == BinOpInit::STRCONCAT) {
while (InitList.size() > 2) {
- Init *RHS = InitList.pop_back_val();
- RHS = (new BinOpInit(Code, InitList.back(), RHS, Type))
+ const Init *RHS = InitList.pop_back_val();
+ RHS = (BinOpInit::Create(Code, InitList.back(), RHS, Type))
->Fold(CurRec, CurMultiClass);
InitList.back() = RHS;
}
}
if (InitList.size() == 2)
- return (new BinOpInit(Code, InitList[0], InitList[1], Type))
+ return (BinOpInit::Create(Code, InitList[0], InitList[1], Type))
->Fold(CurRec, CurMultiClass);
Error(OpLoc, "expected two operands to operator");
@@ -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 = new BitRecTy();
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 = new BitRecTy();
@@ -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;
@@ -982,7 +982,7 @@ Init *TGParser::ParseOperation(Record *CurRec) {
break;
}
}
- return (new TernOpInit(Code, LHS, MHS, RHS, Type))->Fold(CurRec,
+ return (TernOpInit::Create(Code, LHS, MHS, RHS, Type))->Fold(CurRec,
CurMultiClass);
}
}
@@ -1038,11 +1038,11 @@ 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;
+ case tgtok::IntVal: R = IntInit::Create(Lex.getCurIntVal()); Lex.Lex(); break;
case tgtok::StrVal: {
std::string Val = Lex.getCurStrVal();
Lex.Lex();
@@ -1053,15 +1053,15 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
Lex.Lex();
}
- R = new StringInit(Val);
+ R = StringInit::Create(Val);
break;
}
case tgtok::CodeFragment:
- R = new CodeInit(Lex.getCurStrVal());
+ R = CodeInit::Create(Lex.getCurStrVal());
Lex.Lex();
break;
case tgtok::question:
- R = new UnsetInit();
+ R = UnsetInit::Create();
Lex.Lex();
break;
case tgtok::Id: {
@@ -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) {
@@ -1110,12 +1110,12 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
Records.addDef(NewRec);
// The result of the expression is a reference to the new record.
- return new DefInit(NewRec);
+ return DefInit::Create(NewRec);
}
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,21 +1127,22 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
}
Lex.Lex(); // eat the '}'
- BitsInit *Result = new BitsInit(Vals.size());
+ SmallVector<const Init *, 16> NewBits(Vals.size());
+
for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
- Init *Bit = Vals[i]->convertInitializerTo(new BitRecTy());
+ const Init *Bit = Vals[i]->convertInitializerTo(new BitRecTy());
if (Bit == 0) {
Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+
") is not convertable to a bit");
return 0;
}
- Result->setBit(Vals.size()-i-1, Bit);
+ NewBits[Vals.size()-i-1] = Bit;
}
- return Result;
+ return BitsInit::Create(NewBits.begin(), NewBits.end());
}
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;
@@ -1189,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;
@@ -1236,7 +1237,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
DeducedEltTy = EltTy;
}
- return new ListInit(Vals, DeducedEltTy);
+ return ListInit::Create(Vals, DeducedEltTy);
}
case tgtok::l_paren: { // Value ::= '(' IDValue DagArgList ')'
Lex.Lex(); // eat the '('
@@ -1245,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.
@@ -1259,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 Init*, std::string> > DagArgs;
if (Lex.getCode() != tgtok::r_paren) {
DagArgs = ParseDagArgList(CurRec);
if (DagArgs.empty()) return 0;
@@ -1271,7 +1272,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
}
Lex.Lex(); // eat the ')'
- return new DagInit(Operator, OperatorName, DagArgs);
+ return DagInit::Create(Operator, OperatorName, DagArgs);
}
case tgtok::XHead:
@@ -1301,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.
@@ -1361,7 +1362,7 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) {
Result->getAsString() + "'");
return 0;
}
- Result = new FieldInit(Result, Lex.getCurStrVal());
+ Result = FieldInit::Create(Result, Lex.getCurStrVal());
Lex.Lex(); // eat field name
break;
}
@@ -1372,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 Init*, std::string> >
TGParser::ParseDagArgList(Record *CurRec) {
- std::vector<std::pair<llvm::Init*, std::string> > Result;
+ std::vector<std::pair<const 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 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 Init*, std::string> >();
}
VarName = Lex.getCurStrVal();
Lex.Lex(); // eat the VarName.
@@ -1407,9 +1408,10 @@ TGParser::ParseDagArgList(Record *CurRec) {
///
/// ValueList ::= Value (',' Value)
///
-std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec,
- RecTy *EltTy) {
- std::vector<Init*> Result;
+std::vector<const Init*> TGParser::ParseValueList(Record *CurRec,
+ Record *ArgsRec,
+ RecTy *EltTy) {
+ std::vector<const Init*> Result;
RecTy *ItemType = EltTy;
unsigned int ArgN = 0;
if (ArgsRec != 0 && EltTy == 0) {
@@ -1420,7 +1422,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
@@ -1429,7 +1431,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??");
@@ -1437,7 +1439,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;
@@ -1490,7 +1492,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 "";
@@ -1574,7 +1576,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)
@@ -1774,7 +1776,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.
@@ -1948,7 +1950,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 94a1c2b2b2..562c36173f 100644
--- a/utils/TableGen/TGParser.h
+++ b/utils/TableGen/TGParser.h
@@ -33,10 +33,10 @@ 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,
- SMLoc L)
+ 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,20 @@ 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 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/TableGen.cpp b/utils/TableGen/TableGen.cpp
index e8eacb841d..23a67c0b84 100644
--- a/utils/TableGen/TableGen.cpp
+++ b/utils/TableGen/TableGen.cpp
@@ -208,6 +208,7 @@ int main(int argc, char **argv) {
if (error_code ec = MemoryBuffer::getFileOrSTDIN(InputFilename.c_str(), File)) {
errs() << "Could not open input file '" << InputFilename << "': "
<< ec.message() <<"\n";
+ Init::ReleaseMemory();
return 1;
}
MemoryBuffer *F = File.take();
@@ -221,25 +222,30 @@ int main(int argc, char **argv) {
TGParser Parser(SrcMgr, Records);
- if (Parser.ParseFile())
+ if (Parser.ParseFile()) {
+ Init::ReleaseMemory();
return 1;
+ }
std::string Error;
tool_output_file Out(OutputFilename.c_str(), Error);
if (!Error.empty()) {
errs() << argv[0] << ": error opening " << OutputFilename
<< ":" << Error << "\n";
+ Init::ReleaseMemory();
return 1;
}
if (!DependFilename.empty()) {
if (OutputFilename == "-") {
errs() << argv[0] << ": the option -d must be used together with -o\n";
+ Init::ReleaseMemory();
return 1;
}
tool_output_file DepOut(DependFilename.c_str(), Error);
if (!Error.empty()) {
errs() << argv[0] << ": error opening " << DependFilename
<< ":" << Error << "\n";
+ Init::ReleaseMemory();
return 1;
}
DepOut.os() << DependFilename << ":";
@@ -382,11 +388,14 @@ int main(int argc, char **argv) {
}
default:
assert(1 && "Invalid Action");
+ Init::ReleaseMemory();
return 1;
}
// Declare success.
Out.keep();
+
+ Init::ReleaseMemory();
return 0;
} catch (const TGError &Error) {
@@ -399,5 +408,7 @@ int main(int argc, char **argv) {
errs() << argv[0] << ": Unknown unexpected exception occurred.\n";
}
+ Init::ReleaseMemory();
+
return 1;
}
diff --git a/utils/TableGen/X86RecognizableInstr.cpp b/utils/TableGen/X86RecognizableInstr.cpp
index f7518a988c..f7170c41e7 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);
}