/// 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!");
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;
}
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;
}
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--) {
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);
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
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,
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;
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;
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;
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()
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;
<< "(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";
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";
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;
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");
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);
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 {
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);
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;
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;
}
}
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();
}
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!";
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;
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, ";
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, ";
R->getValueAsBit("isPseudo"))
continue;
- BitsInit *BI = R->getValueAsBitsInit("Inst");
+ const BitsInit *BI = R->getValueAsBitsInit("Inst");
unsigned numBits = BI->getNumBits();
- SmallVector<Init *, 16> NewBits(numBits);
+ SmallVector<const Init *, 16> NewBits(numBits);
for (unsigned bit = 0, end = numBits / 2; bit != end; ++bit) {
unsigned bitSwapIdx = numBits - bit - 1;
- Init *OrigBit = BI->getBit(bit);
- Init *BitSwap = BI->getBit(bitSwapIdx);
+ const Init *OrigBit = BI->getBit(bit);
+ const Init *BitSwap = BI->getBit(bitSwapIdx);
NewBits[bit] = BitSwap;
NewBits[bitSwapIdx] = OrigBit;
}
NewBits[middle] = BI->getBit(middle);
}
- BitsInit *NewBI = new BitsInit(ArrayRef<Init *>(NewBits));
+ BitsInit *NewBI = new BitsInit(ArrayRef<const Init *>(NewBits));
// Update the bits in reversed order so that emitInstrOpBits will get the
// correct endianness.
// 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;
}
}
void CodeEmitterGen::
-AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName,
+AddCodeToMergeInOperand(Record *R, const BitsInit *BI, const std::string &VarName,
unsigned &NumberedOp,
std::string &Case, CodeGenTarget &Target) {
CodeGenInstruction &CGI = Target.getInstruction(R);
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;
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";
void emitMachineOpEmitter(raw_ostream &o, const std::string &Namespace);
void emitGetValueBit(raw_ostream &o, const std::string &Namespace);
void reverseBits(std::vector<Record*> &Insts);
- int getVariableBit(const std::string &VarName, BitsInit *BI, int bit);
+ int getVariableBit(const std::string &VarName, const BitsInit *BI, int bit);
std::string getInstructionCase(Record *R, CodeGenTarget &Target);
void
- AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName,
+ AddCodeToMergeInOperand(Record *R, const BitsInit *BI, const std::string &VarName,
unsigned &NumberedOp,
std::string &Case, CodeGenTarget &Target);
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)
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
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);
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
// 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);
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);
}
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()));
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!");
return 0;
unsigned IID =
- dynamic_cast<IntInit*>(getChild(0)->getLeafValue())->getValue();
+ dynamic_cast<const IntInit*>(getChild(0)->getLeafValue())->getValue();
return &CDP.getIntrinsicInfo(IID);
}
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;
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)
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. :)
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;
}
// 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, ""));
}
-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
/// (foo GPR, imm) -> (foo GPR, (imm))
if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag"))
return ParseTreePattern(new DagInit(DI, "",
- std::vector<std::pair<Init*, std::string> >()),
+ std::vector<std::pair<const Init*, std::string> >()),
OpName);
// Input argument?
return Res;
}
- if (IntInit *II = dynamic_cast<IntInit*>(TheInit)) {
+ if (const IntInit *II = dynamic_cast<const IntInit*>(TheInit)) {
if (!OpName.empty())
error("Constant int argument should not have a name!");
return new TreePatternNode(II, 1);
}
- if (BitsInit *BI = dynamic_cast<BitsInit*>(TheInit)) {
+ if (const BitsInit *BI = dynamic_cast<const BitsInit*>(TheInit)) {
// Turn this into an IntInit.
- Init *II = BI->convertInitializerTo(IntRecTy::get());
- if (II == 0 || !dynamic_cast<IntInit*>(II))
+ const Init *II = BI->convertInitializerTo(IntRecTy::get());
+ if (II == 0 || !dynamic_cast<const IntInit*>(II))
error("Bits value must be constants!");
return ParseTreePattern(II, OpName);
}
- DagInit *Dag = dynamic_cast<DagInit*>(TheInit);
+ const DagInit *Dag = dynamic_cast<const DagInit*>(TheInit);
if (!Dag) {
TheInit->dump();
error("Pattern has unexpected init kind!");
}
- DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator());
+ const DefInit *OpDef = dynamic_cast<const DefInit*>(Dag->getOperator());
if (!OpDef) error("Pattern has unexpected operator type!");
Record *Operator = OpDef->getDef();
// 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;
// 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;
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 ||
// 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())
// Find some SDNode.
assert(!SDNodes.empty() && "No SDNodes parsed?");
- Init *SomeSDNode = DefInit::get(SDNodes.begin()->first);
+ const Init *SomeSDNode = DefInit::get(SDNodes.begin()->first);
for (unsigned iter = 0; iter != 2; ++iter) {
for (unsigned i = 0, e = DefaultOps[iter].size(); i != e; ++i) {
- DagInit *DefaultInfo = DefaultOps[iter][i]->getValueAsDag("DefaultOps");
+ const DagInit *DefaultInfo = DefaultOps[iter][i]->getValueAsDag("DefaultOps");
// Clone the DefaultInfo dag node, changing the operator from 'ops' to
// SomeSDnode so that we can parse this.
- std::vector<std::pair<Init*, std::string> > Ops;
+ std::vector<std::pair<const Init*, std::string> > Ops;
for (unsigned op = 0, e = DefaultInfo->getNumArgs(); op != e; ++op)
Ops.push_back(std::make_pair(DefaultInfo->getArg(op),
DefaultInfo->getArgName(op)));
- DagInit *DI = new DagInit(SomeSDNode, "", Ops);
+ const DagInit *DI = new DagInit(SomeSDNode, "", Ops);
// Create a TreePattern to parse this.
TreePattern P(DefaultOps[iter][i], DI, false, *this);
// 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!");
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 {
}
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();
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());
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!");
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);
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")) {
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
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!");
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");
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.
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;
/// 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.
///
: 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);
}
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(); }
/// 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);
void dump() const;
private:
- TreePatternNode *ParseTreePattern(Init *DI, StringRef OpName);
+ TreePatternNode *ParseTreePattern(const Init *DI, StringRef OpName);
void ComputeNamedNodes();
void ComputeNamedNodes(TreePatternNode *N);
};
/// 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)
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.
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; }
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
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
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);
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!";
std::string EncoderMethod;
std::string OperandType = "OPERAND_UNKNOWN";
unsigned NumOps = 1;
- DagInit *MIOpInfo = 0;
+ const DagInit *MIOpInfo = 0;
if (Rec->isSubClassOf("RegisterOperand")) {
PrintMethod = Rec->getValueAsString("PrintMethod");
} else if (Rec->isSubClassOf("Operand")) {
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";
}
// 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 + "'";
/// 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
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.
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");
// 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)
// 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);
/// 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.
OperandInfo(Record *R, const std::string &N, const std::string &PMN,
const std::string &EMN, const std::string &OT, unsigned MION,
- unsigned MINO, DagInit *MIOI)
+ unsigned MINO, const DagInit *MIOI)
: Rec(R), Name(N), PrinterMethodName(PMN), EncoderMethodName(EMN),
OperandType(OT), MIOperandNo(MION), MINumOperands(MINO),
MIOperandInfo(MIOI) {}
std::string AsmString;
/// Result - The result instruction.
- DagInit *Result;
+ const DagInit *Result;
/// ResultInst - The instruction generated by the alias (decoded from
/// Result).
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);
};
}
// 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());
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());
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)
// Precompute some types.
Record *RegisterCl = Def->getRecords().getClass("Register");
RecTy *RegisterRecTy = RecordRecTy::get(RegisterCl);
- StringInit *BlankName = new StringInit("");
+ const StringInit *BlankName = new StringInit("");
// Zip them up.
for (unsigned n = 0; n != Length; ++n) {
std::string Name;
Record *Proto = Lists[0][n];
- std::vector<Init*> Tuple;
+ std::vector<const Init*> Tuple;
unsigned CostPerUse = 0;
for (unsigned i = 0; i != Dim; ++i) {
Record *Reg = Lists[i][n];
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) {
}
// 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() +
// 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() +
// 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!");
}
// 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") &&
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.
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();
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
--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.
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 =
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();
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();
// 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
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--) {
}
}
-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;
}
protected:
// Populates the insn given the uid.
void insnWithID(insn_t &Insn, unsigned Opcode) const {
- BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef, "Inst");
+ const BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef, "Inst");
for (unsigned i = 0; i < BitWidth; ++i)
Insn.push_back(bitFromBits(Bits, i));
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;
// 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)
}
// For each operand, see if we can figure out where it is encoded.
- for (std::vector<std::pair<Init*, std::string> >::iterator
+ for (std::vector<std::pair<const Init*, std::string> >::iterator
NI = InOutOperands.begin(), NE = InOutOperands.end(); NI != NE; ++NI) {
std::string Decoder = "";
// 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;
}
RecordVal *DecoderString = TypeRecord->getValue("DecoderMethod");
- StringInit *String = DecoderString ?
- dynamic_cast<StringInit*>(DecoderString->getValue()) : 0;
+ const StringInit *String = DecoderString ?
+ dynamic_cast<const StringInit*>(DecoderString->getValue()) : 0;
if (!isReg && String && String->getValue() != "")
Decoder = String->getValue();
unsigned Offset = 0;
for (unsigned bi = 0; bi < Bits.getNumBits(); ++bi) {
- VarBitInit *BI = dynamic_cast<VarBitInit*>(Bits.getBit(bi));
+ const VarBitInit *BI = dynamic_cast<const VarBitInit*>(Bits.getBit(bi));
if (!BI) {
if (Base != ~0U) {
OpInfo.addField(Base, Width, Offset);
}
continue;
}
+ if (!BI) continue;
- VarInit *Var = dynamic_cast<VarInit*>(BI->getVariable());
+ const VarInit *Var = dynamic_cast<const VarInit*>(BI->getVariable());
assert(Var);
if (Var->getName() != NI->second &&
Var->getName() != TiedNames[NI->second]) {
// 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.
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;
}
}
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();
unsigned Flags;
std::string Help;
unsigned MultiVal;
- Init* InitVal;
+ const Init* InitVal;
OptionDescription(OptionType::OptionType t = OptionType::Switch,
const std::string& n = "",
}
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);
/// operator() - Just forwards to the corresponding property
/// handler.
- void operator() (Init* I) {
+ void operator() (const Init* I) {
InvokeDagInitHandler(this, I);
}
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)
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));
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;
}
}
- void operator() (Init* I) {
+ void operator() (const Init* I) {
InvokeDagInitHandler(this, I);
}
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;
}
isReallyJoin = true;
}
else {
- Init* I = d.getArg(0);
+ const Init* I = d.getArg(0);
isReallyJoin = InitPtrToBool(I);
}
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()));
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)
{
}
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);
}
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));
}
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));
}
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);
}
}
- void operator() (Init* I) {
+ void operator() (const Init* I) {
InvokeDagInitHandler(this, I);
}
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)) {
// 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));
}
// 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
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");
// 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";
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"));
// 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";
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();
}
}
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"));
// 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";
// 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") ||
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 =
// 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!");
SmallVector<PseudoExpansion, 64> Expansions;
- unsigned addDagOperandMapping(Record *Rec, DagInit *Dag,
+ unsigned addDagOperandMapping(Record *Rec, const DagInit *Dag,
CodeGenInstruction &Insn,
IndexedMap<OpData> &OperandMap,
unsigned BaseIdx);
return ListTy;
}
-Init *BitRecTy::convertValue(BitsInit *BI) {
+const Init *BitRecTy::convertValue(const BitsInit *BI) {
if (BI->getNumBits() != 1) return 0; // Only accept if just one bit!
return BI->getBit(0);
}
return RHS->getNumBits() == 1;
}
-Init *BitRecTy::convertValue(IntInit *II) {
+const Init *BitRecTy::convertValue(const IntInit *II) {
int64_t Val = II->getValue();
if (Val != 0 && Val != 1) return 0; // Only accept 0 or 1 for a bit!
return new BitInit(Val != 0);
}
-Init *BitRecTy::convertValue(TypedInit *VI) {
+const Init *BitRecTy::convertValue(const TypedInit *VI) {
if (dynamic_cast<BitRecTy*>(VI->getType()))
return VI; // Accept variable if it is already of bit type!
return 0;
return "bits<" + utostr(Size) + ">";
}
-Init *BitsRecTy::convertValue(UnsetInit *UI) {
- SmallVector<Init *, 16> NewBits(Size);
+const Init *BitsRecTy::convertValue(const UnsetInit *UI) {
+ SmallVector<const Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
NewBits[i] = new UnsetInit();
- return new BitsInit(ArrayRef<Init *>(NewBits));
+ return new BitsInit(ArrayRef<const Init *>(NewBits));
}
-Init *BitsRecTy::convertValue(BitInit *UI) {
+const Init *BitsRecTy::convertValue(const BitInit *UI) {
if (Size != 1) return 0; // Can only convert single bit.
- return new BitsInit(ArrayRef<Init *>(UI));
+ return new BitsInit(ArrayRef<const Init *>(UI));
}
/// canFitInBitfield - Return true if the number of bits is large enough to hold
/// convertValue from Int initializer to bits type: Split the integer up into the
/// appropriate bits.
///
-Init *BitsRecTy::convertValue(IntInit *II) {
+const Init *BitsRecTy::convertValue(const IntInit *II) {
int64_t Value = II->getValue();
// Make sure this bitfield is large enough to hold the integer value.
if (!canFitInBitfield(Value, Size))
return 0;
- SmallVector<Init *, 16> NewBits(Size);
+ SmallVector<const Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
NewBits[i] = new BitInit(Value & (1LL << i));
- return new BitsInit(ArrayRef<Init *>(NewBits));
+ return new BitsInit(ArrayRef<const Init *>(NewBits));
}
-Init *BitsRecTy::convertValue(BitsInit *BI) {
+const Init *BitsRecTy::convertValue(const BitsInit *BI) {
// If the number of bits is right, return it. Otherwise we need to expand or
// truncate.
if (BI->getNumBits() == Size) return BI;
return 0;
}
-Init *BitsRecTy::convertValue(TypedInit *VI) {
+const Init *BitsRecTy::convertValue(const TypedInit *VI) {
if (BitsRecTy *BRT = dynamic_cast<BitsRecTy*>(VI->getType()))
if (BRT->Size == Size) {
- SmallVector<Init *, 16> NewBits(Size);
+ SmallVector<const Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
NewBits[i] = new VarBitInit(VI, i);
- return new BitsInit(ArrayRef<Init *>(NewBits));
+ return new BitsInit(ArrayRef<const Init *>(NewBits));
}
if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType()))
- return new BitsInit(VI);
+ return new BitsInit(ArrayRef<const Init *>(VI));
- if (TernOpInit *Tern = dynamic_cast<TernOpInit*>(VI)) {
+ if (const TernOpInit *Tern = dynamic_cast<const TernOpInit*>(VI)) {
if (Tern->getOpcode() == TernOpInit::IF) {
- Init *LHS = Tern->getLHS();
- Init *MHS = Tern->getMHS();
- Init *RHS = Tern->getRHS();
+ const Init *LHS = Tern->getLHS();
+ const Init *MHS = Tern->getMHS();
+ const Init *RHS = Tern->getRHS();
- IntInit *MHSi = dynamic_cast<IntInit*>(MHS);
- IntInit *RHSi = dynamic_cast<IntInit*>(RHS);
+ const IntInit *MHSi = dynamic_cast<const IntInit*>(MHS);
+ const IntInit *RHSi = dynamic_cast<const IntInit*>(RHS);
if (MHSi && RHSi) {
int64_t MHSVal = MHSi->getValue();
int64_t RHSVal = RHSi->getValue();
if (canFitInBitfield(MHSVal, Size) && canFitInBitfield(RHSVal, Size)) {
- SmallVector<Init *, 16> NewBits(Size);
+ SmallVector<const Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
NewBits[i] =
new IntInit((RHSVal & (1LL << i)) ? 1 : 0),
VI->getType());
- return new BitsInit(ArrayRef<Init *>(NewBits));
+ return new BitsInit(ArrayRef<const Init *>(NewBits));
}
} else {
- BitsInit *MHSbs = dynamic_cast<BitsInit*>(MHS);
- BitsInit *RHSbs = dynamic_cast<BitsInit*>(RHS);
+ const BitsInit *MHSbs = dynamic_cast<const BitsInit*>(MHS);
+ const BitsInit *RHSbs = dynamic_cast<const BitsInit*>(RHS);
if (MHSbs && RHSbs) {
- SmallVector<Init *, 16> NewBits(Size);
+ SmallVector<const Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
NewBits[i] = new TernOpInit(TernOpInit::IF, LHS,
RHSbs->getBit(i),
VI->getType());
- return new BitsInit(ArrayRef<Init *>(NewBits));
+ return new BitsInit(ArrayRef<const Init *>(NewBits));
}
}
}
return 0;
}
-Init *IntRecTy::convertValue(BitInit *BI) {
+const Init *IntRecTy::convertValue(const BitInit *BI) {
return new IntInit(BI->getValue());
}
-Init *IntRecTy::convertValue(BitsInit *BI) {
+const Init *IntRecTy::convertValue(const BitsInit *BI) {
int64_t Result = 0;
for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
- if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) {
+ if (const BitInit *Bit = dynamic_cast<const BitInit*>(BI->getBit(i))) {
Result |= Bit->getValue() << i;
} else {
return 0;
return new IntInit(Result);
}
-Init *IntRecTy::convertValue(TypedInit *TI) {
+const Init *IntRecTy::convertValue(const TypedInit *TI) {
if (TI->getType()->typeIsConvertibleTo(this))
return TI; // Accept variable if already of the right type!
return 0;
}
-Init *StringRecTy::convertValue(UnOpInit *BO) {
+const Init *StringRecTy::convertValue(const UnOpInit *BO) {
if (BO->getOpcode() == UnOpInit::CAST) {
- Init *L = BO->getOperand()->convertInitializerTo(this);
+ const Init *L = BO->getOperand()->convertInitializerTo(this);
if (L == 0) return 0;
if (L != BO->getOperand())
return new UnOpInit(UnOpInit::CAST, L, new StringRecTy);
return BO;
}
- return convertValue((TypedInit*)BO);
+ return convertValue((const TypedInit*)BO);
}
-Init *StringRecTy::convertValue(BinOpInit *BO) {
+const Init *StringRecTy::convertValue(const BinOpInit *BO) {
if (BO->getOpcode() == BinOpInit::STRCONCAT) {
- Init *L = BO->getLHS()->convertInitializerTo(this);
- Init *R = BO->getRHS()->convertInitializerTo(this);
+ const Init *L = BO->getLHS()->convertInitializerTo(this);
+ const Init *R = BO->getRHS()->convertInitializerTo(this);
if (L == 0 || R == 0) return 0;
if (L != BO->getLHS() || R != BO->getRHS())
return new BinOpInit(BinOpInit::STRCONCAT, L, R, new StringRecTy);
return BO;
}
- return convertValue((TypedInit*)BO);
+ return convertValue((const TypedInit*)BO);
}
-Init *StringRecTy::convertValue(TypedInit *TI) {
+const Init *StringRecTy::convertValue(const TypedInit *TI) {
if (dynamic_cast<StringRecTy*>(TI->getType()))
return TI; // Accept variable if already of the right type!
return 0;
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;
return new ListInit(Elements, this);
}
-Init *ListRecTy::convertValue(TypedInit *TI) {
+const Init *ListRecTy::convertValue(const TypedInit *TI) {
// Ensure that TI is compatible with our class.
if (ListRecTy *LRT = dynamic_cast<ListRecTy*>(TI->getType()))
if (LRT->getElementType()->typeIsConvertibleTo(getElementType()))
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 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 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()) ||
void Init::dump() const { return print(errs()); }
-Init *BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
- SmallVector<Init *, 16> NewBits(Bits.size());
+const Init *
+BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
+ SmallVector<const Init *, 16> NewBits(Bits.size());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= getNumBits())
return 0;
NewBits[i] = getBit(Bits[i]);
}
- return new BitsInit(ArrayRef<Init *>(NewBits));
+ return new BitsInit(ArrayRef<const Init *>(NewBits));
}
std::string BitsInit::getAsString() const {
std::string Result = "{ ";
for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
if (i) Result += ", ";
- if (Init *Bit = getBit(e-i-1))
+ if (const Init *Bit = getBit(e-i-1))
Result += Bit->getAsString();
else
Result += "*";
// resolveReferences - If there are any field references that refer to fields
// that have been filled in, we can propagate the values now.
//
-Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) {
+const Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) const {
bool Changed = false;
- SmallVector<Init *, 16> NewBits(getNumBits());
+ SmallVector<const Init *, 16> NewBits(getNumBits());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
- Init *B;
- Init *CurBit = getBit(i);
+ const Init *B;
+ const Init *CurBit = getBit(i);
do {
B = CurBit;
}
if (Changed)
- return new BitsInit(ArrayRef<Init *>(NewBits));
+ return new BitsInit(ArrayRef<const Init *>(NewBits));
return this;
}
return itostr(Value);
}
-Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
- SmallVector<Init *, 16> NewBits(Bits.size());
+const Init *
+IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
+ SmallVector<const Init *, 16> NewBits(Bits.size());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= 64)
NewBits[i] = new BitInit(Value & (INT64_C(1) << Bits[i]));
}
- return new BitsInit(ArrayRef<Init *>(NewBits));
+ return new BitsInit(ArrayRef<const Init *>(NewBits));
}
-Init *ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
- std::vector<Init*> Vals;
+const Init *
+ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const {
+ std::vector<const Init*> Vals;
for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
if (Elements[i] >= getSize())
return 0;
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;
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;
}
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);
}
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);
}
return 0;
}
-Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
+const Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
switch (getOpcode()) {
default: assert(0 && "Unknown unop");
case CAST: {
if (getType()->getAsString() == "string") {
- StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+ const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
if (LHSs) {
return LHSs;
}
- DefInit *LHSd = dynamic_cast<DefInit*>(LHS);
+ const DefInit *LHSd = dynamic_cast<const DefInit*>(LHS);
if (LHSd) {
return new StringInit(LHSd->getDef()->getName());
}
} else {
- StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+ const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
if (LHSs) {
std::string Name = LHSs->getValue();
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");
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");
// they are not convertible to Init **. Fortunately,
// RandomAccessIterator::operator * is guaranteed to return an
// lvalue.
- ListInit *Result = new ListInit(ArrayRef<Init *>(&*begin, end - begin),
- LHSl->getType());
+ ListInit *Result =
+ new ListInit(ArrayRef<const Init *>(&*begin, end - begin),
+ LHSl->getType());
return Result;
}
break;
}
case EMPTY: {
- ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
+ const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
if (LHSl) {
if (LHSl->getSize() == 0) {
return new IntInit(1);
return new IntInit(0);
}
}
- StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+ const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
if (LHSs) {
if (LHSs->getValue().empty()) {
return new IntInit(1);
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 Result + "(" + LHS->getAsString() + ")";
}
-Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
+const Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
switch (getOpcode()) {
default: assert(0 && "Unknown binop");
case CONCAT: {
- DagInit *LHSs = dynamic_cast<DagInit*>(LHS);
- DagInit *RHSs = dynamic_cast<DagInit*>(RHS);
+ const DagInit *LHSs = dynamic_cast<const DagInit*>(LHS);
+ const DagInit *RHSs = dynamic_cast<const DagInit*>(RHS);
if (LHSs && RHSs) {
- DefInit *LOp = dynamic_cast<DefInit*>(LHSs->getOperator());
- DefInit *ROp = dynamic_cast<DefInit*>(RHSs->getOperator());
+ const DefInit *LOp = dynamic_cast<const DefInit*>(LHSs->getOperator());
+ const DefInit *ROp = dynamic_cast<const DefInit*>(RHSs->getOperator());
if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef())
throw "Concated Dag operators do not match!";
- std::vector<Init*> Args;
+ std::vector<const Init*> Args;
std::vector<std::string> ArgNames;
for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) {
Args.push_back(LHSs->getArg(i));
break;
}
case STRCONCAT: {
- StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
- StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
+ const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+ const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS);
if (LHSs && RHSs)
return new StringInit(LHSs->getValue() + RHSs->getValue());
break;
case EQ: {
// try to fold eq comparison for 'bit' and 'int', otherwise fallback
// to string objects.
- IntInit* L =
- dynamic_cast<IntInit*>(LHS->convertInitializerTo(IntRecTy::get()));
- IntInit* R =
- dynamic_cast<IntInit*>(RHS->convertInitializerTo(IntRecTy::get()));
+ const IntInit* L =
+ dynamic_cast<const IntInit*>(LHS->convertInitializerTo(IntRecTy::get()));
+ const IntInit* R =
+ dynamic_cast<const IntInit*>(RHS->convertInitializerTo(IntRecTy::get()));
if (L && R)
return new IntInit(L->getValue() == R->getValue());
- StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
- StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
+ const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+ const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS);
// Make sure we've resolved
if (LHSs && RHSs)
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;
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 Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
}
-static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
- Record *CurRec, MultiClass *CurMultiClass);
+static const Init *ForeachHelper(const Init *LHS, const Init *MHS,
+ const Init *RHS, RecTy *Type,
+ Record *CurRec, MultiClass *CurMultiClass);
-static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
- RecTy *Type, Record *CurRec,
- MultiClass *CurMultiClass) {
- std::vector<Init *> NewOperands;
+static const Init *EvaluateOperation(const OpInit *RHSo, const Init *LHS,
+ const Init *Arg,
+ RecTy *Type, Record *CurRec,
+ MultiClass *CurMultiClass) {
+ std::vector<const Init *> NewOperands;
- TypedInit *TArg = dynamic_cast<TypedInit*>(Arg);
+ const TypedInit *TArg = dynamic_cast<const TypedInit*>(Arg);
// If this is a dag, recurse
if (TArg && TArg->getType()->getAsString() == "dag") {
- Init *Result = ForeachHelper(LHS, Arg, RHSo, Type,
+ const Init *Result = ForeachHelper(LHS, Arg, RHSo, Type,
CurRec, CurMultiClass);
if (Result != 0) {
return Result;
}
for (int i = 0; i < RHSo->getNumOperands(); ++i) {
- OpInit *RHSoo = dynamic_cast<OpInit*>(RHSo->getOperand(i));
+ const OpInit *RHSoo = dynamic_cast<const OpInit*>(RHSo->getOperand(i));
if (RHSoo) {
- Init *Result = EvaluateOperation(RHSoo, LHS, Arg,
+ const Init *Result = EvaluateOperation(RHSoo, LHS, Arg,
Type, CurRec, CurMultiClass);
if (Result != 0) {
NewOperands.push_back(Result);
}
// Now run the operator and use its result as the new leaf
- OpInit *NewOp = RHSo->clone(NewOperands);
- Init *NewVal = NewOp->Fold(CurRec, CurMultiClass);
+ const OpInit *NewOp = RHSo->clone(NewOperands);
+ const Init *NewVal = NewOp->Fold(CurRec, CurMultiClass);
if (NewVal != NewOp) {
delete NewOp;
return NewVal;
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");
if ((MHSd && DagType) || (MHSl && ListType)) {
if (MHSd) {
- Init *Val = MHSd->getOperator();
- Init *Result = EvaluateOperation(RHSo, LHS, Val,
+ const Init *Val = MHSd->getOperator();
+ const Init *Result = EvaluateOperation(RHSo, LHS, Val,
Type, CurRec, CurMultiClass);
if (Result != 0) {
Val = Result;
}
- std::vector<std::pair<Init *, std::string> > args;
+ std::vector<std::pair<const Init *, std::string> > args;
for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) {
- Init *Arg;
+ const Init *Arg;
std::string ArgName;
Arg = MHSd->getArg(i);
ArgName = MHSd->getArgName(i);
// Process args
- Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type,
+ const Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type,
CurRec, CurMultiClass);
if (Result != 0) {
Arg = Result;
return new DagInit(Val, "", args);
}
if (MHSl) {
- std::vector<Init *> NewOperands;
- std::vector<Init *> NewList(MHSl->begin(), MHSl->end());
+ std::vector<const Init *> NewOperands;
+ std::vector<const Init *> NewList(MHSl->begin(), MHSl->end());
- for (std::vector<Init *>::iterator li = NewList.begin(),
+ for (std::vector<const Init *>::iterator li = NewList.begin(),
liend = NewList.end();
li != liend;
++li) {
- Init *Item = *li;
+ const Init *Item = *li;
NewOperands.clear();
for(int i = 0; i < RHSo->getNumOperands(); ++i) {
// First, replace the foreach variable with the list item
}
// 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 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)
}
case FOREACH: {
- Init *Result = ForeachHelper(LHS, MHS, RHS, getType(),
+ const Init *Result = ForeachHelper(LHS, MHS, RHS, getType(),
CurRec, CurMultiClass);
if (Result != 0) {
return Result;
}
case IF: {
- IntInit *LHSi = dynamic_cast<IntInit*>(LHS);
- if (Init *I = LHS->convertInitializerTo(IntRecTy::get()))
- LHSi = dynamic_cast<IntInit*>(I);
+ const IntInit *LHSi = dynamic_cast<const IntInit*>(LHS);
+ if (const Init *I = LHS->convertInitializerTo(IntRecTy::get()))
+ LHSi = dynamic_cast<const IntInit*>(I);
if (LHSi) {
if (LHSi->getValue()) {
return MHS;
return this;
}
-Init *TernOpInit::resolveReferences(Record &R, const RecordVal *RV) {
- Init *lhs = LHS->resolveReferences(R, RV);
+const Init *TernOpInit::resolveReferences(Record &R,
+ const RecordVal *RV) const {
+ const Init *lhs = LHS->resolveReferences(R, RV);
if (Opc == IF && lhs != LHS) {
- IntInit *Value = dynamic_cast<IntInit*>(lhs);
- if (Init *I = lhs->convertInitializerTo(IntRecTy::get()))
- Value = dynamic_cast<IntInit*>(I);
+ const IntInit *Value = dynamic_cast<const IntInit*>(lhs);
+ if (const Init *I = lhs->convertInitializerTo(IntRecTy::get()))
+ Value = dynamic_cast<const IntInit*>(I);
if (Value != 0) {
// Short-circuit
if (Value->getValue()) {
- Init *mhs = MHS->resolveReferences(R, RV);
+ const Init *mhs = MHS->resolveReferences(R, RV);
return (new TernOpInit(getOpcode(), lhs, mhs,
RHS, getType()))->Fold(&R, 0);
} else {
- Init *rhs = RHS->resolveReferences(R, RV);
+ const Init *rhs = RHS->resolveReferences(R, RV);
return (new TernOpInit(getOpcode(), lhs, MHS,
rhs, getType()))->Fold(&R, 0);
}
}
}
- Init *mhs = MHS->resolveReferences(R, RV);
- Init *rhs = RHS->resolveReferences(R, RV);
+ const Init *mhs = MHS->resolveReferences(R, RV);
+ const Init *rhs = RHS->resolveReferences(R, RV);
if (LHS != lhs || MHS != mhs || RHS != rhs)
return (new TernOpInit(getOpcode(), lhs, mhs, rhs, getType()))->Fold(&R, 0);
return 0;
}
-Init *TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+const Init *
+TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
BitsRecTy *T = dynamic_cast<BitsRecTy*>(getType());
if (T == 0) return 0; // Cannot subscript a non-bits variable.
unsigned NumBits = T->getNumBits();
- SmallVector<Init *, 16> NewBits(Bits.size());
+ SmallVector<const Init *, 16> NewBits(Bits.size());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= NumBits)
return 0;
NewBits[i] = new VarBitInit(this, Bits[i]);
}
- return new BitsInit(ArrayRef<Init *>(NewBits));
+ return new BitsInit(ArrayRef<const Init *>(NewBits));
}
-Init *TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
+const Init *
+TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const {
ListRecTy *T = dynamic_cast<ListRecTy*>(getType());
if (T == 0) return 0; // Cannot subscript a non-list variable.
if (Elements.size() == 1)
return new VarListElementInit(this, Elements[0]);
- std::vector<Init*> ListInits;
+ std::vector<const Init*> ListInits;
ListInits.reserve(Elements.size());
for (unsigned i = 0, e = Elements.size(); i != e; ++i)
ListInits.push_back(new VarListElementInit(this, Elements[i]));
}
-Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV,
- unsigned Bit) {
+const Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV,
+ unsigned Bit) const {
if (R.isTemplateArg(getName())) return 0;
if (IRV && IRV->getName() != getName()) return 0;
RecordVal *RV = R.getValue(getName());
assert(RV && "Reference to a non-existent variable?");
- assert(dynamic_cast<BitsInit*>(RV->getValue()));
- BitsInit *BI = (BitsInit*)RV->getValue();
+ assert(dynamic_cast<const BitsInit*>(RV->getValue()));
+ const BitsInit *BI = (const BitsInit*)RV->getValue();
assert(Bit < BI->getNumBits() && "Bit reference out of range!");
- Init *B = BI->getBit(Bit);
+ const Init *B = BI->getBit(Bit);
// If the bit is set to some value, or if we are resolving a reference to a
// specific variable and that variable is explicitly unset, then replace the
// VarBitInit with it.
- if (IRV || !dynamic_cast<UnsetInit*>(B))
+ if (IRV || !dynamic_cast<const UnsetInit*>(B))
return B;
return 0;
}
-Init *VarInit::resolveListElementReference(Record &R, const RecordVal *IRV,
- unsigned Elt) {
+const Init *VarInit::resolveListElementReference(Record &R,
+ const RecordVal *IRV,
+ unsigned Elt) const {
if (R.isTemplateArg(getName())) return 0;
if (IRV && IRV->getName() != getName()) return 0;
RecordVal *RV = R.getValue(getName());
assert(RV && "Reference to a non-existent variable?");
- ListInit *LI = dynamic_cast<ListInit*>(RV->getValue());
+ const ListInit *LI = dynamic_cast<const ListInit*>(RV->getValue());
if (!LI) {
- VarInit *VI = dynamic_cast<VarInit*>(RV->getValue());
+ const VarInit *VI = dynamic_cast<const VarInit*>(RV->getValue());
assert(VI && "Invalid list element!");
return new VarListElementInit(VI, Elt);
}
if (Elt >= LI->getSize())
return 0; // Out of range reference.
- Init *E = LI->getElement(Elt);
+ const Init *E = LI->getElement(Elt);
// If the element is set to some value, or if we are resolving a reference
// to a specific variable and that variable is explicitly unset, then
// replace the VarListElementInit with it.
- if (IRV || !dynamic_cast<UnsetInit*>(E))
+ if (IRV || !dynamic_cast<const UnsetInit*>(E))
return E;
return 0;
}
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;
/// 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;
}
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;
}
return TI->getAsString() + "[" + utostr(Element) + "]";
}
-Init *VarListElementInit::resolveReferences(Record &R, const RecordVal *RV) {
- if (Init *I = getVariable()->resolveListElementReference(R, RV,
+const Init *VarListElementInit::resolveReferences(Record &R,
+ const RecordVal *RV) const {
+ if (const Init *I = getVariable()->resolveListElementReference(R, RV,
getElementNum()))
return I;
return this;
}
-Init *VarListElementInit::resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) {
+const Init *VarListElementInit::resolveBitReference(Record &R,
+ const RecordVal *RV,
+ unsigned Bit) const {
// FIXME: This should be implemented, to support references like:
// bit B = AA[0]{1};
return 0;
}
-Init *VarListElementInit::
-resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) {
+const Init *VarListElementInit::
+resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) const {
// FIXME: This should be implemented, to support references like:
// int B = AA[0][1];
return 0;
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();
}
return Def->getName();
}
-Init *FieldInit::resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) {
- if (Init *BitsVal = Rec->getFieldInit(R, RV, FieldName))
- if (BitsInit *BI = dynamic_cast<BitsInit*>(BitsVal)) {
+const Init *FieldInit::resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const {
+ if (const Init *BitsVal = Rec->getFieldInit(R, RV, FieldName))
+ if (const BitsInit *BI = dynamic_cast<const BitsInit*>(BitsVal)) {
assert(Bit < BI->getNumBits() && "Bit reference out of range!");
- Init *B = BI->getBit(Bit);
+ const Init *B = BI->getBit(Bit);
- if (dynamic_cast<BitInit*>(B)) // If the bit is set.
+ if (dynamic_cast<const BitInit*>(B)) // If the bit is set.
return B; // Replace the VarBitInit with it.
}
return 0;
}
-Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV,
- unsigned Elt) {
- if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName))
- if (ListInit *LI = dynamic_cast<ListInit*>(ListVal)) {
+const Init *FieldInit::resolveListElementReference(Record &R,
+ const RecordVal *RV,
+ unsigned Elt) const {
+ if (const Init *ListVal = Rec->getFieldInit(R, RV, FieldName))
+ if (const ListInit *LI = dynamic_cast<const ListInit*>(ListVal)) {
if (Elt >= LI->getSize()) return 0;
- Init *E = LI->getElement(Elt);
+ const Init *E = LI->getElement(Elt);
// If the element is set to some value, or if we are resolving a
// reference to a specific variable and that variable is explicitly
// unset, then replace the VarListElementInit with it.
- if (RV || !dynamic_cast<UnsetInit*>(E))
+ if (RV || !dynamic_cast<const UnsetInit*>(E))
return E;
}
return 0;
}
-Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) {
- Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec;
+const Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const {
+ const Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec;
- Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName);
+ const Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName);
if (BitsVal) {
- Init *BVR = BitsVal->resolveReferences(R, RV);
+ const Init *BVR = BitsVal->resolveReferences(R, RV);
return BVR->isComplete() ? BVR : this;
}
return this;
}
-Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) {
- std::vector<Init*> NewArgs;
+const Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) const {
+ std::vector<const Init*> NewArgs;
for (unsigned i = 0, e = Args.size(); i != e; ++i)
NewArgs.push_back(Args[i]->resolveReferences(R, RV));
- Init *Op = Val->resolveReferences(R, RV);
+ const Init *Op = Val->resolveReferences(R, RV);
if (Args != NewArgs || Op != Val)
return new DagInit(Op, ValName, NewArgs, ArgNames);
/// 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));
}
}
/// 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 `" +
/// 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!";
/// 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!";
///
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() +
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!";
///
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() +
///
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() +
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!";
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!";
/// 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!";
ListRecTy *getListTy();
public: // These methods should only be called from subclasses of Init
- virtual Init *convertValue( UnsetInit *UI) { return 0; }
- virtual Init *convertValue( BitInit *BI) { return 0; }
- virtual Init *convertValue( BitsInit *BI) { return 0; }
- virtual Init *convertValue( IntInit *II) { return 0; }
- virtual Init *convertValue(StringInit *SI) { return 0; }
- virtual Init *convertValue( ListInit *LI) { return 0; }
- virtual Init *convertValue( UnOpInit *UI) {
- return convertValue((TypedInit*)UI);
+ virtual const Init *convertValue( const UnsetInit *UI) { return 0; }
+ virtual const Init *convertValue( const BitInit *BI) { return 0; }
+ virtual const Init *convertValue( const BitsInit *BI) { return 0; }
+ virtual const Init *convertValue( const IntInit *II) { return 0; }
+ virtual const Init *convertValue(const StringInit *SI) { return 0; }
+ virtual const Init *convertValue( const ListInit *LI) { return 0; }
+ virtual const Init *convertValue( const UnOpInit *UI) {
+ return convertValue((const TypedInit*)UI);
}
- virtual Init *convertValue( BinOpInit *UI) {
- return convertValue((TypedInit*)UI);
+ virtual const Init *convertValue( const BinOpInit *UI) {
+ return convertValue((const TypedInit*)UI);
}
- virtual Init *convertValue( TernOpInit *UI) {
- return convertValue((TypedInit*)UI);
+ virtual const Init *convertValue( const TernOpInit *UI) {
+ return convertValue((const TypedInit*)UI);
}
- virtual Init *convertValue( CodeInit *CI) { return 0; }
- virtual Init *convertValue(VarBitInit *VB) { return 0; }
- virtual Init *convertValue( DefInit *DI) { return 0; }
- virtual Init *convertValue( DagInit *DI) { return 0; }
- virtual Init *convertValue( TypedInit *TI) { return 0; }
- virtual Init *convertValue( VarInit *VI) {
- return convertValue((TypedInit*)VI);
+ virtual const Init *convertValue( const CodeInit *CI) { return 0; }
+ virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
+ virtual const Init *convertValue( const DefInit *DI) { return 0; }
+ virtual const Init *convertValue( const DagInit *DI) { return 0; }
+ virtual const Init *convertValue( const TypedInit *TI) { return 0; }
+ virtual const Init *convertValue( const VarInit *VI) {
+ return convertValue((const TypedInit*)VI);
}
- virtual Init *convertValue( FieldInit *FI) {
- return convertValue((TypedInit*)FI);
+ virtual const Init *convertValue( const FieldInit *FI) {
+ return convertValue((const TypedInit*)FI);
}
public: // These methods should only be called by subclasses of RecTy.
public:
static BitRecTy *get() { return &Shared; }
- virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
- virtual Init *convertValue( BitInit *BI) { return (Init*)BI; }
- virtual Init *convertValue( BitsInit *BI);
- virtual Init *convertValue( IntInit *II);
- virtual Init *convertValue(StringInit *SI) { return 0; }
- virtual Init *convertValue( ListInit *LI) { return 0; }
- virtual Init *convertValue( CodeInit *CI) { return 0; }
- virtual Init *convertValue(VarBitInit *VB) { return (Init*)VB; }
- virtual Init *convertValue( DefInit *DI) { return 0; }
- virtual Init *convertValue( DagInit *DI) { return 0; }
- virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
- virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
- virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
- virtual Init *convertValue( TypedInit *TI);
- virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
- virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
+ virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
+ virtual const Init *convertValue( const BitInit *BI) { return (const Init*)BI; }
+ virtual const Init *convertValue( const BitsInit *BI);
+ virtual const Init *convertValue( const IntInit *II);
+ virtual const Init *convertValue(const StringInit *SI) { return 0; }
+ virtual const Init *convertValue( const ListInit *LI) { return 0; }
+ virtual const Init *convertValue( const CodeInit *CI) { return 0; }
+ virtual const Init *convertValue(const VarBitInit *VB) { return (const Init*)VB; }
+ virtual const Init *convertValue( const DefInit *DI) { return 0; }
+ virtual const Init *convertValue( const DagInit *DI) { return 0; }
+ virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual const Init *convertValue( const TypedInit *TI);
+ virtual const Init *convertValue( const VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "bit"; }
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;
public:
static IntRecTy *get() { return &Shared; }
- virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
- virtual Init *convertValue( BitInit *BI);
- virtual Init *convertValue( BitsInit *BI);
- virtual Init *convertValue( IntInit *II) { return (Init*)II; }
- virtual Init *convertValue(StringInit *SI) { return 0; }
- virtual Init *convertValue( ListInit *LI) { return 0; }
- virtual Init *convertValue( CodeInit *CI) { return 0; }
- virtual Init *convertValue(VarBitInit *VB) { return 0; }
- virtual Init *convertValue( DefInit *DI) { return 0; }
- virtual Init *convertValue( DagInit *DI) { return 0; }
- virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
- virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
- virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
- virtual Init *convertValue( TypedInit *TI);
- virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
- virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
+ virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
+ virtual const Init *convertValue( const BitInit *BI);
+ virtual const Init *convertValue( const BitsInit *BI);
+ virtual const Init *convertValue( const IntInit *II) { return (const Init*)II; }
+ virtual const Init *convertValue(const StringInit *SI) { return 0; }
+ virtual const Init *convertValue( const ListInit *LI) { return 0; }
+ virtual const Init *convertValue( const CodeInit *CI) { return 0; }
+ virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
+ virtual const Init *convertValue( const DefInit *DI) { return 0; }
+ virtual const Init *convertValue( const DagInit *DI) { return 0; }
+ virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual const Init *convertValue( const TypedInit *TI);
+ virtual const Init *convertValue( const VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "int"; }
public:
static StringRecTy *get() { return &Shared; }
- virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
- virtual Init *convertValue( BitInit *BI) { return 0; }
- virtual Init *convertValue( BitsInit *BI) { return 0; }
- virtual Init *convertValue( IntInit *II) { return 0; }
- virtual Init *convertValue(StringInit *SI) { return (Init*)SI; }
- virtual Init *convertValue( ListInit *LI) { return 0; }
- virtual Init *convertValue( UnOpInit *BO);
- virtual Init *convertValue( BinOpInit *BO);
- virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);}
-
- virtual Init *convertValue( CodeInit *CI) { return 0; }
- virtual Init *convertValue(VarBitInit *VB) { return 0; }
- virtual Init *convertValue( DefInit *DI) { return 0; }
- virtual Init *convertValue( DagInit *DI) { return 0; }
- virtual Init *convertValue( TypedInit *TI);
- virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
- virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
+ virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
+ virtual const Init *convertValue( const BitInit *BI) { return 0; }
+ virtual const Init *convertValue( const BitsInit *BI) { return 0; }
+ virtual const Init *convertValue( const IntInit *II) { return 0; }
+ virtual const Init *convertValue(const StringInit *SI) { return (const Init*)SI; }
+ virtual const Init *convertValue( const ListInit *LI) { return 0; }
+ virtual const Init *convertValue( const UnOpInit *BO);
+ virtual const Init *convertValue( const BinOpInit *BO);
+ virtual const Init *convertValue( const TernOpInit *BO) { return RecTy::convertValue(BO);}
+
+ virtual const Init *convertValue( const CodeInit *CI) { return 0; }
+ virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
+ virtual const Init *convertValue( const DefInit *DI) { return 0; }
+ virtual const Init *convertValue( const DagInit *DI) { return 0; }
+ virtual const Init *convertValue( const TypedInit *TI);
+ virtual const Init *convertValue( const VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "string"; }
static ListRecTy *get(RecTy *T) { return T->getListTy(); }
RecTy *getElementType() const { return Ty; }
- virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
- virtual Init *convertValue( BitInit *BI) { return 0; }
- virtual Init *convertValue( BitsInit *BI) { return 0; }
- virtual Init *convertValue( IntInit *II) { return 0; }
- virtual Init *convertValue(StringInit *SI) { return 0; }
- virtual Init *convertValue( ListInit *LI);
- virtual Init *convertValue( CodeInit *CI) { return 0; }
- virtual Init *convertValue(VarBitInit *VB) { return 0; }
- virtual Init *convertValue( DefInit *DI) { return 0; }
- virtual Init *convertValue( DagInit *DI) { return 0; }
- virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
- virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
- virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
- virtual Init *convertValue( TypedInit *TI);
- virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
- virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
+ virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
+ virtual const Init *convertValue( const BitInit *BI) { return 0; }
+ virtual const Init *convertValue( const BitsInit *BI) { return 0; }
+ virtual const Init *convertValue( const IntInit *II) { return 0; }
+ virtual const Init *convertValue(const StringInit *SI) { return 0; }
+ virtual const Init *convertValue( const ListInit *LI);
+ virtual const Init *convertValue( const CodeInit *CI) { return 0; }
+ virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
+ virtual const Init *convertValue( const DefInit *DI) { return 0; }
+ virtual const Init *convertValue( const DagInit *DI) { return 0; }
+ virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual const Init *convertValue( const TypedInit *TI);
+ virtual const Init *convertValue( const VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const;
public:
static CodeRecTy *get() { return &Shared; }
- virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
- virtual Init *convertValue( BitInit *BI) { return 0; }
- virtual Init *convertValue( BitsInit *BI) { return 0; }
- virtual Init *convertValue( IntInit *II) { return 0; }
- virtual Init *convertValue(StringInit *SI) { return 0; }
- virtual Init *convertValue( ListInit *LI) { return 0; }
- virtual Init *convertValue( CodeInit *CI) { return (Init*)CI; }
- virtual Init *convertValue(VarBitInit *VB) { return 0; }
- virtual Init *convertValue( DefInit *DI) { return 0; }
- virtual Init *convertValue( DagInit *DI) { return 0; }
- virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
- virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
- virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
- virtual Init *convertValue( TypedInit *TI);
- virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
- virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
+ virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
+ virtual const Init *convertValue( const BitInit *BI) { return 0; }
+ virtual const Init *convertValue( const BitsInit *BI) { return 0; }
+ virtual const Init *convertValue( const IntInit *II) { return 0; }
+ virtual const Init *convertValue(const StringInit *SI) { return 0; }
+ virtual const Init *convertValue( const ListInit *LI) { return 0; }
+ virtual const Init *convertValue( const CodeInit *CI) { return (const Init*)CI; }
+ virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
+ virtual const Init *convertValue( const DefInit *DI) { return 0; }
+ virtual const Init *convertValue( const DagInit *DI) { return 0; }
+ virtual const Init *convertValue( const UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual const Init *convertValue( const BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual const Init *convertValue( const TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual const Init *convertValue( const TypedInit *TI);
+ virtual const Init *convertValue( const VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "code"; }
public:
static DagRecTy *get() { return &Shared; }
- virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
- virtual Init *convertValue( BitInit *BI) { return 0; }
- virtual Init *convertValue( BitsInit *BI) { return 0; }
- virtual Init *convertValue( IntInit *II) { return 0; }
- virtual Init *convertValue(StringInit *SI) { return 0; }
- virtual Init *convertValue( ListInit *LI) { return 0; }
- virtual Init *convertValue( CodeInit *CI) { return 0; }
- virtual Init *convertValue(VarBitInit *VB) { return 0; }
- virtual Init *convertValue( DefInit *DI) { return 0; }
- virtual Init *convertValue( UnOpInit *BO);
- virtual Init *convertValue( BinOpInit *BO);
- virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);}
- virtual Init *convertValue( DagInit *CI) { return (Init*)CI; }
- virtual Init *convertValue( TypedInit *TI);
- virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
- virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
+ virtual const Init *convertValue( const UnsetInit *UI) { return (const Init*)UI; }
+ virtual const Init *convertValue( const BitInit *BI) { return 0; }
+ virtual const Init *convertValue( const BitsInit *BI) { return 0; }
+ virtual const Init *convertValue( const IntInit *II) { return 0; }
+ virtual const Init *convertValue(const StringInit *SI) { return 0; }
+ virtual const Init *convertValue( const ListInit *LI) { return 0; }
+ virtual const Init *convertValue( const CodeInit *CI) { return 0; }
+ virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
+ virtual const Init *convertValue( const DefInit *DI) { return 0; }
+ virtual const Init *convertValue( const UnOpInit *BO);
+ virtual const Init *convertValue( const BinOpInit *BO);
+ virtual const Init *convertValue( const TernOpInit *BO) { return RecTy::convertValue(BO);}
+ virtual const Init *convertValue( const DagInit *CI) { return (const Init*)CI; }
+ virtual const Init *convertValue( const TypedInit *TI);
+ virtual const Init *convertValue( const VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual const Init *convertValue( const FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "dag"; }
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;
/// 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;
}
/// 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;
}
/// 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;
}
/// 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;
}
};
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
/// 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;
};
///
class UnsetInit : public Init {
public:
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
bool getValue() const { return Value; }
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
/// It contains a vector of bits, whose size is determined by the type.
///
class BitsInit : public Init {
- std::vector<Init*> Bits;
+ std::vector<const Init*> Bits;
public:
explicit BitsInit(unsigned Size) : Bits(Size) {}
- BitsInit(ArrayRef<Init *> Range) : Bits(Range.begin(), Range.end()) {}
+ BitsInit(ArrayRef<const Init *> Range) : Bits(Range.begin(), Range.end()) {}
unsigned getNumBits() const { return Bits.size(); }
- Init *getBit(unsigned Bit) const {
+ const Init *getBit(unsigned Bit) const {
assert(Bit < Bits.size() && "Bit index out of range!");
return Bits[Bit];
}
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
- virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
+ virtual const Init *
+ convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
virtual bool isComplete() const {
for (unsigned i = 0; i != getNumBits(); ++i)
}
virtual std::string getAsString() const;
- virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+ virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
};
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;
/// 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;
}
/// 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;
}
const std::string &getValue() const { return Value; }
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
/// 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;
}
/// 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;
}
const std::string &getValue() const { return Value; }
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
/// ListInit - [AL, AH, CL] - Represent a list of defs
///
class ListInit : public TypedInit {
- std::vector<Init*> Values;
+ std::vector<const Init*> Values;
public:
- typedef std::vector<Init*>::const_iterator const_iterator;
+ typedef std::vector<const Init*>::const_iterator const_iterator;
- explicit ListInit(std::vector<Init*> &Vs, RecTy *EltTy)
+ explicit ListInit(std::vector<const Init*> &Vs, RecTy *EltTy)
: TypedInit(ListRecTy::get(EltTy)) {
Values.swap(Vs);
}
- explicit ListInit(ArrayRef<Init *> Range, RecTy *EltTy)
+ explicit ListInit(ArrayRef<const Init *> Range, RecTy *EltTy)
: TypedInit(ListRecTy::get(EltTy)), Values(Range.begin(), Range.end()) {}
unsigned getSize() const { return Values.size(); }
- Init *getElement(unsigned i) const {
+ const Init *getElement(unsigned i) const {
assert(i < Values.size() && "List element index out of range!");
return Values[i];
}
Record *getElementAsRecord(unsigned i) const;
- Init *convertInitListSlice(const std::vector<unsigned> &Elements);
+ const Init *convertInitListSlice(const std::vector<unsigned> &Elements) const;
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
/// If a value is set for the variable later, this method will be called on
/// users of the value to allow the value to propagate out.
///
- virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+ virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
virtual std::string getAsString() const;
- ArrayRef<Init*> getValues() const { return Values; }
+ ArrayRef<const Init*> getValues() const { return Values; }
inline const_iterator begin() const { return Values.begin(); }
inline const_iterator end () const { return Values.end(); }
/// 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;
}
/// 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(RecTy *Type) : TypedInit(Type) {}
// Clone - Clone this operator, replacing arguments with the new list
- virtual OpInit *clone(std::vector<Init *> &Operands) = 0;
+ virtual const OpInit *clone(std::vector<const Init *> &Operands) const = 0;
virtual int getNumOperands() const = 0;
- virtual Init *getOperand(int i) = 0;
+ virtual const Init *getOperand(int i) const = 0;
// Fold - If possible, fold this to a simpler init. Return this if not
// possible to fold.
- virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) = 0;
+ virtual const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0;
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
- virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit);
- virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
- unsigned Elt);
+ virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const;
+ virtual const Init *resolveListElementReference(Record &R,
+ const RecordVal *RV,
+ unsigned Elt) const;
};
enum UnaryOp { CAST, HEAD, TAIL, EMPTY };
private:
UnaryOp Opc;
- Init *LHS;
+ const Init *LHS;
public:
- UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type) :
+ UnOpInit(UnaryOp opc, const Init *lhs, RecTy *Type) :
OpInit(Type), Opc(opc), LHS(lhs) {
}
// Clone - Clone this operator, replacing arguments with the new list
- virtual OpInit *clone(std::vector<Init *> &Operands) {
+ virtual const OpInit *clone(std::vector<const Init *> &Operands) const {
assert(Operands.size() == 1 &&
"Wrong number of operands for unary operation");
return new UnOpInit(getOpcode(), *Operands.begin(), getType());
}
int getNumOperands() const { return 1; }
- Init *getOperand(int i) {
+ const Init *getOperand(int i) const {
assert(i == 0 && "Invalid operand id for unary operator");
return getOperand();
}
UnaryOp getOpcode() const { return Opc; }
- Init *getOperand() const { return LHS; }
+ const Init *getOperand() const { return LHS; }
// Fold - If possible, fold this to a simpler init. Return this if not
// possible to fold.
- Init *Fold(Record *CurRec, MultiClass *CurMultiClass);
+ const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
- virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+ virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
virtual std::string getAsString() const;
};
enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, EQ };
private:
BinaryOp Opc;
- Init *LHS, *RHS;
+ const Init *LHS, *RHS;
public:
- BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
+ BinOpInit(BinaryOp opc, const Init *lhs, const Init *rhs, RecTy *Type) :
OpInit(Type), Opc(opc), LHS(lhs), RHS(rhs) {
}
// Clone - Clone this operator, replacing arguments with the new list
- virtual OpInit *clone(std::vector<Init *> &Operands) {
+ virtual const OpInit *clone(std::vector<const Init *> &Operands) const {
assert(Operands.size() == 2 &&
"Wrong number of operands for binary operation");
return new BinOpInit(getOpcode(), Operands[0], Operands[1], getType());
}
int getNumOperands() const { return 2; }
- Init *getOperand(int i) {
+ const Init *getOperand(int i) const {
assert((i == 0 || i == 1) && "Invalid operand id for binary operator");
if (i == 0) {
return getLHS();
}
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;
};
enum TernaryOp { SUBST, FOREACH, IF };
private:
TernaryOp Opc;
- Init *LHS, *MHS, *RHS;
+ const Init *LHS, *MHS, *RHS;
public:
- TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs, RecTy *Type) :
+ TernOpInit(TernaryOp opc, const Init *lhs, const Init *mhs, const Init *rhs,
+ RecTy *Type) :
OpInit(Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) {
}
// Clone - Clone this operator, replacing arguments with the new list
- virtual OpInit *clone(std::vector<Init *> &Operands) {
+ virtual const OpInit *clone(std::vector<const Init *> &Operands) const {
assert(Operands.size() == 3 &&
"Wrong number of operands for ternary operation");
return new TernOpInit(getOpcode(), Operands[0], Operands[1], Operands[2],
}
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) {
}
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;
};
explicit VarInit(const std::string &VN, RecTy *T)
: TypedInit(T), VarName(VN) {}
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
const std::string &getName() const { return VarName; }
- virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit);
- virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
- unsigned Elt);
+ virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const;
+ virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) const;
virtual RecTy *getFieldType(const std::string &FieldName) const;
- virtual Init *getFieldInit(Record &R, const RecordVal *RV,
- const std::string &FieldName) const;
+ virtual const Init *getFieldInit(Record &R, const RecordVal *RV,
+ const std::string &FieldName) const;
/// resolveReferences - This method is used by classes that refer to other
/// variables which may not be defined at the time they expression is formed.
/// If a value is set for the variable later, this method will be called on
/// users of the value to allow the value to propagate out.
///
- virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+ virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
virtual std::string getAsString() const { return VarName; }
};
/// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field.
///
class VarBitInit : public Init {
- TypedInit *TI;
+ const TypedInit *TI;
unsigned Bit;
public:
- VarBitInit(TypedInit *T, unsigned B) : TI(T), Bit(B) {
+ VarBitInit(const TypedInit *T, unsigned B) : TI(T), Bit(B) {
assert(T->getType() && dynamic_cast<BitsRecTy*>(T->getType()) &&
((BitsRecTy*)T->getType())->getNumBits() > B &&
"Illegal VarBitInit expression!");
}
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
- TypedInit *getVariable() const { return TI; }
+ const TypedInit *getVariable() const { return TI; }
unsigned getBitNum() const { return Bit; }
virtual std::string getAsString() const;
- virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+ virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
};
/// VarListElementInit - List[4] - Represent access to one element of a var or
/// field.
class VarListElementInit : public TypedInit {
- TypedInit *TI;
+ const TypedInit *TI;
unsigned Element;
public:
- VarListElementInit(TypedInit *T, unsigned E)
+ VarListElementInit(const TypedInit *T, unsigned E)
: TypedInit(dynamic_cast<ListRecTy*>(T->getType())->getElementType()),
TI(T), Element(E) {
assert(T->getType() && dynamic_cast<ListRecTy*>(T->getType()) &&
"Illegal VarBitInit expression!");
}
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
- TypedInit *getVariable() const { return TI; }
+ const TypedInit *getVariable() const { return TI; }
unsigned getElementNum() const { return Element; }
- virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit);
+ virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const;
/// resolveListElementReference - This method is used to implement
/// VarListElementInit::resolveReferences. If the list element is resolvable
/// now, we return the resolved value, otherwise we return null.
- virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
- unsigned Elt);
+ virtual const Init *resolveListElementReference(Record &R,
+ const RecordVal *RV,
+ unsigned Elt) const;
virtual std::string getAsString() const;
- virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+ virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
};
/// DefInit - AL - Represent a reference to a 'def' in the description
public:
static DefInit *get(Record*);
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
Record *getDef() const { return Def; }
- //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
+ //virtual const Init *
+ //convertInitializerBitRange(const std::vector<unsigned> &Bits);
virtual RecTy *getFieldType(const std::string &FieldName) const;
- virtual Init *getFieldInit(Record &R, const RecordVal *RV,
- const std::string &FieldName) const;
+ virtual const Init *getFieldInit(Record &R, const RecordVal *RV,
+ const std::string &FieldName) const;
virtual std::string getAsString() const;
/// 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;
}
/// 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;
}
/// FieldInit - X.Y - Represent a reference to a subfield of a variable
///
class FieldInit : public TypedInit {
- Init *Rec; // Record we are referring to
+ const Init *Rec; // Record we are referring to
std::string FieldName; // Field we are accessing
public:
- FieldInit(Init *R, const std::string &FN)
+ FieldInit(const Init *R, const std::string &FN)
: TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) {
assert(getType() && "FieldInit with non-record type!");
}
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
- virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit);
- virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
- unsigned Elt);
+ virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) const;
+ virtual const Init *resolveListElementReference(Record &R,
+ const RecordVal *RV,
+ unsigned Elt) const;
- virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+ virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
virtual std::string getAsString() const {
return Rec->getAsString() + "." + FieldName;
/// argument can have a name associated with it.
///
class DagInit : public TypedInit {
- Init *Val;
+ const Init *Val;
std::string ValName;
- std::vector<Init*> Args;
+ std::vector<const Init*> Args;
std::vector<std::string> ArgNames;
public:
- DagInit(Init *V, std::string VN,
- const std::vector<std::pair<Init*, std::string> > &args)
+ DagInit(const Init *V, std::string VN,
+ const std::vector<std::pair<const Init*, std::string> > &args)
: TypedInit(DagRecTy::get()), Val(V), ValName(VN) {
Args.reserve(args.size());
ArgNames.reserve(args.size());
ArgNames.push_back(args[i].second);
}
}
- DagInit(Init *V, std::string VN, const std::vector<Init*> &args,
+ DagInit(const Init *V, std::string VN, const std::vector<const Init*> &args,
const std::vector<std::string> &argNames)
: TypedInit(DagRecTy::get()), Val(V), ValName(VN), Args(args),
ArgNames(argNames) { }
- virtual Init *convertInitializerTo(RecTy *Ty) {
+ virtual const Init *convertInitializerTo(RecTy *Ty) const {
return Ty->convertValue(this);
}
- Init *getOperator() const { return Val; }
+ const Init *getOperator() const { return Val; }
const std::string &getName() const { return ValName; }
unsigned getNumArgs() const { return Args.size(); }
- Init *getArg(unsigned Num) const {
+ const Init *getArg(unsigned Num) const {
assert(Num < Args.size() && "Arg number out of range!");
return Args[Num];
}
return ArgNames[Num];
}
- virtual Init *resolveReferences(Record &R, const RecordVal *RV);
+ virtual const Init *resolveReferences(Record &R, const RecordVal *RV) const;
virtual std::string getAsString() const;
- typedef std::vector<Init*>::const_iterator const_arg_iterator;
+ typedef std::vector<const Init*>::const_iterator const_arg_iterator;
typedef std::vector<std::string>::const_iterator const_name_iterator;
inline const_arg_iterator arg_begin() const { return Args.begin(); }
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;
}
std::string Name;
RecTy *Ty;
unsigned Prefix;
- Init *Value;
+ const Init *Value;
public:
RecordVal(const std::string &N, RecTy *T, unsigned P);
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;
/// 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
/// 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
/// 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
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];
}
// (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();
// (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;
// 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);
// (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)
// (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)
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)
// (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)
// (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();
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) {
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());
}
// 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());
/// 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
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>
struct SubClassReference {
SMLoc RefLoc;
Record *Rec;
- std::vector<Init*> TemplateArgs;
+ std::vector<const Init*> TemplateArgs;
SubClassReference() : Rec(0) {}
bool isInvalid() const { return Rec == 0; }
struct SubMultiClassReference {
SMLoc RefLoc;
MultiClass *MC;
- std::vector<Init*> TemplateArgs;
+ std::vector<const Init*> TemplateArgs;
SubMultiClassReference() : MC(0) {}
bool isInvalid() const { return MC == 0; }
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) {
/// 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;
// 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;
// initializer.
//
if (!BitList.empty()) {
- BitsInit *CurVal = dynamic_cast<BitsInit*>(RV->getValue());
+ const BitsInit *CurVal = dynamic_cast<const BitsInit*>(RV->getValue());
if (CurVal == 0)
return Error(Loc, "Value '" + ValName + "' is not a bits type");
// Convert the incoming value to a bits type of the appropriate size...
- Init *BI = V->convertInitializerTo(BitsRecTy::get(BitList.size()));
+ const Init *BI = V->convertInitializerTo(BitsRecTy::get(BitList.size()));
if (BI == 0) {
V->convertInitializerTo(BitsRecTy::get(BitList.size()));
return Error(Loc, "Initializer is not compatible with bit range");
}
// We should have a BitsInit type now.
- BitsInit *BInit = dynamic_cast<BitsInit*>(BI);
+ const BitsInit *BInit = dynamic_cast<const BitsInit*>(BI);
assert(BInit != 0);
- SmallVector<Init *, 16> NewBits(CurVal->getNumBits());
+ SmallVector<const Init *, 16> NewBits(CurVal->getNumBits());
// Loop over bits, assigning values as appropriate.
for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
if (NewBits[i] == 0)
NewBits[i] = CurVal->getBit(i);
- V = new BitsInit(ArrayRef<Init *>(NewBits));
+ V = new BitsInit(ArrayRef<const Init *>(NewBits));
}
if (RV->setValue(V))
/// 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();
/// 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))
///
/// Operation ::= XOperator ['<' Type '>'] '(' Args ')'
///
-Init *TGParser::ParseOperation(Record *CurRec) {
+const Init *TGParser::ParseOperation(Record *CurRec) {
switch (Lex.getCode()) {
default:
TokError("unknown operation");
}
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;
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;
}
Lex.Lex(); // eat the '('
- SmallVector<Init*, 2> InitList;
+ SmallVector<const Init*, 2> InitList;
InitList.push_back(ParseValue(CurRec));
if (InitList.back() == 0) return 0;
// shorthand for nesting them.
if (Code == BinOpInit::STRCONCAT) {
while (InitList.size() > 2) {
- Init *RHS = InitList.pop_back_val();
+ const Init *RHS = InitList.pop_back_val();
RHS = (new BinOpInit(Code, InitList.back(), RHS, Type))
->Fold(CurRec, CurMultiClass);
InitList.back() = RHS;
}
Lex.Lex(); // eat the '('
- Init *LHS = ParseValue(CurRec);
+ const Init *LHS = ParseValue(CurRec);
if (LHS == 0) return 0;
if (Lex.getCode() != tgtok::comma) {
}
Lex.Lex(); // eat the ','
- Init *MHS = ParseValue(CurRec);
+ const Init *MHS = ParseValue(CurRec);
if (MHS == 0) return 0;
if (Lex.getCode() != tgtok::comma) {
}
Lex.Lex(); // eat the ','
- Init *RHS = ParseValue(CurRec);
+ const Init *RHS = ParseValue(CurRec);
if (RHS == 0) return 0;
if (Lex.getCode() != tgtok::r_paren) {
case tgtok::XIf: {
// FIXME: The `!if' operator doesn't handle non-TypedInit well at
// all. This can be made much more robust.
- TypedInit *MHSt = dynamic_cast<TypedInit*>(MHS);
- TypedInit *RHSt = dynamic_cast<TypedInit*>(RHS);
+ const TypedInit *MHSt = dynamic_cast<const TypedInit*>(MHS);
+ const TypedInit *RHSt = dynamic_cast<const TypedInit*>(RHS);
RecTy *MHSTy = 0;
RecTy *RHSTy = 0;
if (MHSt == 0 && RHSt == 0) {
- BitsInit *MHSbits = dynamic_cast<BitsInit*>(MHS);
- BitsInit *RHSbits = dynamic_cast<BitsInit*>(RHS);
+ const BitsInit *MHSbits = dynamic_cast<const BitsInit*>(MHS);
+ const BitsInit *RHSbits = dynamic_cast<const BitsInit*>(RHS);
if (MHSbits && RHSbits &&
MHSbits->getNumBits() == RHSbits->getNumBits()) {
Type = BitRecTy::get();
break;
} else {
- BitInit *MHSbit = dynamic_cast<BitInit*>(MHS);
- BitInit *RHSbit = dynamic_cast<BitInit*>(RHS);
+ const BitInit *MHSbit = dynamic_cast<const BitInit*>(MHS);
+ const BitInit *RHSbit = dynamic_cast<const BitInit*>(RHS);
if (MHSbit && RHSbit) {
Type = BitRecTy::get();
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;
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;
/// 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;
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) {
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);
}
Lex.Lex(); // eat the '}'
- SmallVector<Init *, 16> NewBits(Vals.size());
+ SmallVector<const Init *, 16> NewBits(Vals.size());
for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
- Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get());
+ const Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get());
if (Bit == 0) {
Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+
") is not convertable to a bit");
}
NewBits[Vals.size()-i-1] = Bit;
}
- return new BitsInit(ArrayRef<Init *>(NewBits));
+ return new BitsInit(ArrayRef<const Init *>(NewBits));
}
case tgtok::l_square: { // Value ::= '[' ValueList ']'
Lex.Lex(); // eat the '['
- std::vector<Init*> Vals;
+ std::vector<const Init*> Vals;
RecTy *DeducedEltTy = 0;
ListRecTy *GivenListTy = 0;
// 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;
return 0;
}
- Init *Operator = ParseValue(CurRec);
+ const Init *Operator = ParseValue(CurRec);
if (Operator == 0) return 0;
// If the operator name is present, parse it.
Lex.Lex(); // eat the VarName.
}
- std::vector<std::pair<llvm::Init*, std::string> > DagArgs;
+ std::vector<std::pair<const llvm::Init*, std::string> > DagArgs;
if (Lex.getCode() != tgtok::r_paren) {
DagArgs = ParseDagArgList(CurRec);
if (DagArgs.empty()) return 0;
/// 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.
///
/// ParseDagArgList ::= Value (':' VARNAME)?
/// ParseDagArgList ::= ParseDagArgList ',' Value (':' VARNAME)?
-std::vector<std::pair<llvm::Init*, std::string> >
+std::vector<std::pair<const llvm::Init*, std::string> >
TGParser::ParseDagArgList(Record *CurRec) {
- std::vector<std::pair<llvm::Init*, std::string> > Result;
+ std::vector<std::pair<const llvm::Init*, std::string> > Result;
while (1) {
- Init *Val = ParseValue(CurRec);
- if (Val == 0) return std::vector<std::pair<llvm::Init*, std::string> >();
+ const Init *Val = ParseValue(CurRec);
+ if (Val == 0) return std::vector<std::pair<const llvm::Init*, std::string> >();
// If the variable name is present, add it.
std::string VarName;
if (Lex.getCode() == tgtok::colon) {
if (Lex.Lex() != tgtok::VarName) { // eat the ':'
TokError("expected variable name in dag literal");
- return std::vector<std::pair<llvm::Init*, std::string> >();
+ return std::vector<std::pair<const llvm::Init*, std::string> >();
}
VarName = Lex.getCurStrVal();
Lex.Lex(); // eat the VarName.
///
/// ValueList ::= Value (',' Value)
///
-std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec,
+std::vector<const Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec,
RecTy *EltTy) {
- std::vector<Init*> Result;
+ std::vector<const Init*> Result;
RecTy *ItemType = EltTy;
unsigned int ArgN = 0;
if (ArgsRec != 0 && EltTy == 0) {
++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
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??");
++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;
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 "";
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)
}
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.
// 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();
struct LetRecord {
std::string Name;
std::vector<unsigned> Bits;
- Init *Value;
+ const Init *Value;
SMLoc Loc;
- LetRecord(const std::string &N, const std::vector<unsigned> &B, Init *V,
+ LetRecord(const std::string &N, const std::vector<unsigned> &B, const Init *V,
SMLoc L)
: Name(N), Bits(B), Value(V), Loc(L) {
}
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);
SubClassReference ParseSubClassReference(Record *CurRec, bool isDefm);
SubMultiClassReference ParseSubMultiClassReference(MultiClass *CurMC);
- Init *ParseIDValue(Record *CurRec);
- Init *ParseIDValue(Record *CurRec, const std::string &Name, SMLoc NameLoc);
- Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = 0);
- Init *ParseValue(Record *CurRec, RecTy *ItemType = 0);
- std::vector<Init*> ParseValueList(Record *CurRec, Record *ArgsRec = 0, RecTy *EltTy = 0);
- std::vector<std::pair<llvm::Init*, std::string> > ParseDagArgList(Record *);
+ const Init *ParseIDValue(Record *CurRec);
+ const Init *ParseIDValue(Record *CurRec, const std::string &Name, SMLoc NameLoc);
+ const Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = 0);
+ const Init *ParseValue(Record *CurRec, RecTy *ItemType = 0);
+ std::vector<const Init*> ParseValueList(Record *CurRec, Record *ArgsRec = 0, RecTy *EltTy = 0);
+ std::vector<std::pair<const llvm::Init*, std::string> > ParseDagArgList(Record *);
bool ParseOptionalRangeList(std::vector<unsigned> &Ranges);
bool ParseOptionalBitList(std::vector<unsigned> &Ranges);
std::vector<unsigned> ParseRangeList();
bool ParseRangePiece(std::vector<unsigned> &Ranges);
RecTy *ParseType();
- Init *ParseOperation(Record *CurRec);
+ const Init *ParseOperation(Record *CurRec);
RecTy *ParseOperatorType();
std::string ParseObjectName();
Record *ParseClassID();
/// @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!");
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;
/// @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);
}
projects / oota-llvm.git / commitdiff