/// byteFromBitsInit - Return the byte value from a BitsInit.
/// Called from getByteField().
-static uint8_t byteFromBitsInit(const BitsInit &init) {
+static uint8_t byteFromBitsInit(BitsInit &init) {
int width = init.getNumBits();
assert(width <= 8 && "Field is too large for uint8_t!");
uint8_t ret = 0;
for (index = 0; index < width; index++) {
- if (static_cast<const BitInit*>(init.getBit(index))->getValue())
+ if (static_cast<BitInit*>(init.getBit(index))->getValue())
ret |= mask;
mask <<= 1;
}
static uint8_t getByteField(const Record &def, const char *str) {
- const BitsInit *bits = def.getValueAsBitsInit(str);
+ BitsInit *bits = def.getValueAsBitsInit(str);
return byteFromBitsInit(*bits);
}
-static const BitsInit &getBitsField(const Record &def, const char *str) {
- const BitsInit *bits = def.getValueAsBitsInit(str);
+static BitsInit &getBitsField(const Record &def, const char *str) {
+ BitsInit *bits = def.getValueAsBitsInit(str);
return *bits;
}
static int Value(bit_value_t V) {
return ValueNotSet(V) ? -1 : (V == BIT_FALSE ? 0 : 1);
}
-static bit_value_t bitFromBits(const BitsInit &bits, unsigned index) {
- if (const BitInit *bit = dynamic_cast<const BitInit*>(bits.getBit(index)))
+static bit_value_t bitFromBits(BitsInit &bits, unsigned index) {
+ if (BitInit *bit = dynamic_cast<BitInit*>(bits.getBit(index)))
return bit->getValue() ? BIT_TRUE : BIT_FALSE;
// The bit is uninitialized.
return BIT_UNSET;
}
// Prints the bit value for each position.
-static void dumpBits(raw_ostream &o, const BitsInit &bits) {
+static void dumpBits(raw_ostream &o, BitsInit &bits) {
unsigned index;
for (index = bits.getNumBits(); index > 0; index--) {
if (AllInstructions[Opcode]->isPseudo)
return;
- const BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef,
- "Inst");
+ BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef, "Inst");
for (unsigned i = 0; i < BIT_WIDTH; ++i)
Insn[i] = bitFromBits(Bits, i);
const StringRef Name = Def.getName();
uint8_t Form = getByteField(Def, "Form");
- const BitsInit &Bits = getBitsField(Def, "Inst");
+ BitsInit &Bits = getBitsField(Def, "Inst");
// If all the bit positions are not specified; do not decode this instruction.
// We are bound to fail! For proper disassembly, the well-known encoding bits
int SubOpIdx) {
Record *Rec = OI.Rec;
if (SubOpIdx != -1)
- Rec = dynamic_cast<const DefInit*>(OI.MIOperandInfo->getArg(SubOpIdx))->getDef();
+ Rec = dynamic_cast<DefInit*>(OI.MIOperandInfo->getArg(SubOpIdx))->getDef();
if (Rec->isSubClassOf("RegisterOperand")) {
// RegisterOperand may have an associated ParserMatchClass. If it does,
throw "Record `" + Rec->getName() +
"' does not have a ParserMatchClass!\n";
- if (const DefInit *DI= dynamic_cast<const DefInit*>(R->getValue())) {
+ if (DefInit *DI= dynamic_cast<DefInit*>(R->getValue())) {
Record *MatchClass = DI->getDef();
if (ClassInfo *CI = AsmOperandClasses[MatchClass])
return CI;
ClassInfo *CI = AsmOperandClasses[*it];
CI->Kind = ClassInfo::UserClass0 + Index;
- const ListInit *Supers = (*it)->getValueAsListInit("SuperClasses");
+ ListInit *Supers = (*it)->getValueAsListInit("SuperClasses");
for (unsigned i = 0, e = Supers->getSize(); i != e; ++i) {
- const DefInit *DI = dynamic_cast<const DefInit*>(Supers->getElement(i));
+ DefInit *DI = dynamic_cast<DefInit*>(Supers->getElement(i));
if (!DI) {
PrintError((*it)->getLoc(), "Invalid super class reference!");
continue;
CI->ValueName = (*it)->getName();
// Get or construct the predicate method name.
- const Init *PMName = (*it)->getValueInit("PredicateMethod");
- if (const StringInit *SI = dynamic_cast<const StringInit*>(PMName)) {
+ Init *PMName = (*it)->getValueInit("PredicateMethod");
+ if (StringInit *SI = dynamic_cast<StringInit*>(PMName)) {
CI->PredicateMethod = SI->getValue();
} else {
- assert(dynamic_cast<const UnsetInit*>(PMName) &&
+ assert(dynamic_cast<UnsetInit*>(PMName) &&
"Unexpected PredicateMethod field!");
CI->PredicateMethod = "is" + CI->ClassName;
}
// Get or construct the render method name.
- const Init *RMName = (*it)->getValueInit("RenderMethod");
- if (const StringInit *SI = dynamic_cast<const StringInit*>(RMName)) {
+ Init *RMName = (*it)->getValueInit("RenderMethod");
+ if (StringInit *SI = dynamic_cast<StringInit*>(RMName)) {
CI->RenderMethod = SI->getValue();
} else {
- assert(dynamic_cast<const UnsetInit*>(RMName) &&
+ assert(dynamic_cast<UnsetInit*>(RMName) &&
"Unexpected RenderMethod field!");
CI->RenderMethod = "add" + CI->ClassName + "Operands";
}
// Get the parse method name or leave it as empty.
- const Init *PRMName = (*it)->getValueInit("ParserMethod");
- if (const StringInit *SI = dynamic_cast<const StringInit*>(PRMName))
+ Init *PRMName = (*it)->getValueInit("ParserMethod");
+ if (StringInit *SI = dynamic_cast<StringInit*>(PRMName))
CI->ParserMethod = SI->getValue();
AsmOperandClasses[*it] = CI;
void CallingConvEmitter::EmitCallingConv(Record *CC, raw_ostream &O) {
- const ListInit *CCActions = CC->getValueAsListInit("Actions");
+ ListInit *CCActions = CC->getValueAsListInit("Actions");
Counter = 0;
O << "\n\nstatic bool " << CC->getName()
O << IndentStr << "if (";
if (Action->isSubClassOf("CCIfType")) {
- const ListInit *VTs = Action->getValueAsListInit("VTs");
+ ListInit *VTs = Action->getValueAsListInit("VTs");
for (unsigned i = 0, e = VTs->getSize(); i != e; ++i) {
Record *VT = VTs->getElementAsRecord(i);
if (i != 0) O << " ||\n " << IndentStr;
<< "(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))\n"
<< IndentStr << " return false;\n";
} else if (Action->isSubClassOf("CCAssignToReg")) {
- const ListInit *RegList = Action->getValueAsListInit("RegList");
+ ListInit *RegList = Action->getValueAsListInit("RegList");
if (RegList->getSize() == 1) {
O << IndentStr << "if (unsigned Reg = State.AllocateReg(";
O << getQualifiedName(RegList->getElementAsRecord(0)) << ")) {\n";
O << IndentStr << " return false;\n";
O << IndentStr << "}\n";
} else if (Action->isSubClassOf("CCAssignToRegWithShadow")) {
- const ListInit *RegList = Action->getValueAsListInit("RegList");
- const ListInit *ShadowRegList = Action->getValueAsListInit("ShadowRegList");
+ ListInit *RegList = Action->getValueAsListInit("RegList");
+ ListInit *ShadowRegList = Action->getValueAsListInit("ShadowRegList");
if (ShadowRegList->getSize() >0 &&
ShadowRegList->getSize() != RegList->getSize())
throw "Invalid length of list of shadowed registers";
static const std::vector<StringRef>
getValueAsListOfStrings(Record &R, StringRef FieldName) {
- const ListInit *List = R.getValueAsListInit(FieldName);
+ ListInit *List = R.getValueAsListInit(FieldName);
assert (List && "Got a null ListInit");
std::vector<StringRef> Strings;
Strings.reserve(List->getSize());
- for (ListInit::const_iterator i = List->begin(), e = List->end();
- i != e;
- ++i) {
+ for (ListInit::iterator i = List->begin(), e = List->end(); i != e; ++i) {
assert(*i && "Got a null element in a ListInit");
- if (const StringInit *S = dynamic_cast<const StringInit *>(*i))
+ if (StringInit *S = dynamic_cast<StringInit *>(*i))
Strings.push_back(S->getValue());
- else if (const CodeInit *C = dynamic_cast<const CodeInit *>(*i))
+ else if (CodeInit *C = dynamic_cast<CodeInit *>(*i))
Strings.push_back(C->getValue());
else
assert(false && "Got a non-string, non-code element in a ListInit");
static std::string getDiagnosticCategory(const Record *R,
DiagGroupParentMap &DiagGroupParents) {
// If the diagnostic is in a group, and that group has a category, use it.
- if (const DefInit *Group =
- dynamic_cast<const DefInit*>(R->getValueInit("Group"))) {
+ if (DefInit *Group = dynamic_cast<DefInit*>(R->getValueInit("Group"))) {
// Check the diagnostic's diag group for a category.
std::string CatName = getCategoryFromDiagGroup(Group->getDef(),
DiagGroupParents);
OS.write_escaped(R.getValueAsString("Text")) << '"';
// Warning associated with the diagnostic.
- if (const DefInit *DI =
- dynamic_cast<const DefInit*>(R.getValueInit("Group"))) {
+ if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group"))) {
OS << ", \"";
OS.write_escaped(DI->getDef()->getValueAsString("GroupName")) << '"';
} else {
Records.getAllDerivedDefinitions("Diagnostic");
for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
const Record *R = Diags[i];
- const DefInit *DI = dynamic_cast<const DefInit*>(R->getValueInit("Group"));
+ DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("Group"));
if (DI == 0) continue;
std::string GroupName = DI->getDef()->getValueAsString("GroupName");
DiagsInGroup[GroupName].DiagsInGroup.push_back(R);
if (R.getValueAsBit("Hidden"))
return true;
// Not declared as hidden, check the parent package if it is hidden.
- if (const DefInit *DI =
- dynamic_cast<const DefInit*>(R.getValueInit("ParentPackage")))
+ if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("ParentPackage")))
return isHidden(*DI->getDef());
return false;
static std::string getParentPackageFullName(const Record *R) {
std::string name;
- if (const DefInit *DI =
- dynamic_cast<const DefInit*>(R->getValueInit("ParentPackage")))
+ if (DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("ParentPackage")))
name = getPackageFullName(DI->getDef());
return name;
}
}
static std::string getStringValue(const Record &R, StringRef field) {
- if (const StringInit *
- SI = dynamic_cast<const StringInit*>(R.getValueInit(field)))
+ if (StringInit *
+ SI = dynamic_cast<StringInit*>(R.getValueInit(field)))
return SI->getValue();
return std::string();
}
for (unsigned i = 0, e = checkers.size(); i != e; ++i) {
Record *R = checkers[i];
Record *package = 0;
- if (const DefInit *
- DI = dynamic_cast<const DefInit*>(R->getValueInit("ParentPackage")))
+ if (DefInit *
+ DI = dynamic_cast<DefInit*>(R->getValueInit("ParentPackage")))
package = DI->getDef();
if (!isCheckerNamed(R) && !package)
throw "Checker '" + R->getName() + "' is neither named, nor in a package!";
Record *currR = isCheckerNamed(R) ? R : package;
// Insert the checker and its parent packages into the subgroups set of
// the corresponding parent package.
- while (const DefInit *DI =
- dynamic_cast<const DefInit*>(currR->getValueInit("ParentPackage"))) {
+ while (DefInit *DI
+ = dynamic_cast<DefInit*>(currR->getValueInit("ParentPackage"))) {
Record *parentPackage = DI->getDef();
recordGroupMap[parentPackage]->SubGroups.insert(currR);
currR = parentPackage;
}
// Insert the checker into the set of its group.
- if (const DefInit *DI =
- dynamic_cast<const DefInit*>(R->getValueInit("Group")))
+ if (DefInit *DI = dynamic_cast<DefInit*>(R->getValueInit("Group")))
recordGroupMap[DI->getDef()]->Checkers.insert(R);
}
// If a package is in group, add all its checkers and its sub-packages
// checkers into the group.
for (unsigned i = 0, e = packages.size(); i != e; ++i)
- if (const DefInit *DI =
- dynamic_cast<const DefInit*>(packages[i]->getValueInit("Group")))
+ if (DefInit *DI = dynamic_cast<DefInit*>(packages[i]->getValueInit("Group")))
addPackageToCheckerGroup(packages[i], DI->getDef(), recordGroupMap);
typedef std::map<std::string, const Record *> SortedRecords;
OS << "PACKAGE(" << "\"";
OS.write_escaped(getPackageFullName(&R)) << "\", ";
// Group index
- if (const DefInit *DI =
- dynamic_cast<const DefInit*>(R.getValueInit("Group")))
+ if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group")))
OS << groupToSortIndex[DI->getDef()] << ", ";
else
OS << "-1, ";
OS << "\"";
OS.write_escaped(getStringValue(R, "HelpText")) << "\", ";
// Group index
- if (const DefInit *DI =
- dynamic_cast<const DefInit*>(R.getValueInit("Group")))
+ if (DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group")))
OS << groupToSortIndex[DI->getDef()] << ", ";
else
OS << "-1, ";
R->getValueAsBit("isPseudo"))
continue;
- const BitsInit *BI = R->getValueAsBitsInit("Inst");
+ BitsInit *BI = R->getValueAsBitsInit("Inst");
unsigned numBits = BI->getNumBits();
-
- SmallVector<const Init *, 16> NewBits(numBits);
-
+ BitsInit *NewBI = new BitsInit(numBits);
for (unsigned bit = 0, end = numBits / 2; bit != end; ++bit) {
unsigned bitSwapIdx = numBits - bit - 1;
- const Init *OrigBit = BI->getBit(bit);
- const Init *BitSwap = BI->getBit(bitSwapIdx);
- NewBits[bit] = BitSwap;
- NewBits[bitSwapIdx] = OrigBit;
+ Init *OrigBit = BI->getBit(bit);
+ Init *BitSwap = BI->getBit(bitSwapIdx);
+ NewBI->setBit(bit, BitSwap);
+ NewBI->setBit(bitSwapIdx, OrigBit);
}
if (numBits % 2) {
unsigned middle = (numBits + 1) / 2;
- NewBits[middle] = BI->getBit(middle);
+ NewBI->setBit(middle, BI->getBit(middle));
}
-
- const BitsInit *NewBI = BitsInit::get(NewBits.begin(), NewBits.end());
// Update the bits in reversed order so that emitInstrOpBits will get the
// correct endianness.
// If the VarBitInit at position 'bit' matches the specified variable then
// return the variable bit position. Otherwise return -1.
int CodeEmitterGen::getVariableBit(const std::string &VarName,
- const BitsInit *BI, int bit) {
- if (const VarBitInit *VBI =
- dynamic_cast<const VarBitInit*>(BI->getBit(bit))) {
- if (const VarInit *VI = dynamic_cast<const VarInit*>(VBI->getVariable()))
+ BitsInit *BI, int bit) {
+ if (VarBitInit *VBI = dynamic_cast<VarBitInit*>(BI->getBit(bit))) {
+ if (VarInit *VI = dynamic_cast<VarInit*>(VBI->getVariable()))
if (VI->getName() == VarName)
return VBI->getBitNum();
- } else if (const VarInit *VI =
- dynamic_cast<const VarInit*>(BI->getBit(bit))) {
+ } else if (VarInit *VI = dynamic_cast<VarInit*>(BI->getBit(bit))) {
if (VI->getName() == VarName)
return 0;
}
}
void CodeEmitterGen::
-AddCodeToMergeInOperand(Record *R, const BitsInit *BI,
- const std::string &VarName, unsigned &NumberedOp,
+AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName,
+ unsigned &NumberedOp,
std::string &Case, CodeGenTarget &Target) {
CodeGenInstruction &CGI = Target.getInstruction(R);
CodeGenTarget &Target) {
std::string Case;
- const BitsInit *BI = R->getValueAsBitsInit("Inst");
+ BitsInit *BI = R->getValueAsBitsInit("Inst");
const std::vector<RecordVal> &Vals = R->getValues();
unsigned NumberedOp = 0;
continue;
}
- const BitsInit *BI = R->getValueAsBitsInit("Inst");
+ BitsInit *BI = R->getValueAsBitsInit("Inst");
// Start by filling in fixed values.
unsigned Value = 0;
for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) {
- if (const BitInit *B = dynamic_cast<const BitInit*>(BI->getBit(e-i-1)))
+ if (BitInit *B = dynamic_cast<BitInit*>(BI->getBit(e-i-1)))
Value |= B->getValue() << (e-i-1);
}
o << " " << Value << "U," << '\t' << "// " << R->getName() << "\n";
void emitMachineOpEmitter(raw_ostream &o, const std::string &Namespace);
void emitGetValueBit(raw_ostream &o, const std::string &Namespace);
void reverseBits(std::vector<Record*> &Insts);
- int getVariableBit(const std::string &VarName, const BitsInit *BI, int bit);
+ int getVariableBit(const std::string &VarName, BitsInit *BI, int bit);
std::string getInstructionCase(Record *R, CodeGenTarget &Target);
void
- AddCodeToMergeInOperand(Record *R, const BitsInit *BI,
- const std::string &VarName, unsigned &NumberedOp,
+ AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName,
+ unsigned &NumberedOp,
std::string &Case, CodeGenTarget &Target);
};
static void FindDepVarsOf(TreePatternNode *N, DepVarMap &DepMap) {
if (N->isLeaf()) {
- if (dynamic_cast<const DefInit*>(N->getLeafValue()) != NULL)
+ if (dynamic_cast<DefInit*>(N->getLeafValue()) != NULL)
DepMap[N->getName()]++;
} else {
for (size_t i = 0, e = N->getNumChildren(); i != e; ++i)
unsigned Size = 3; // The node itself.
// If the root node is a ConstantSDNode, increases its size.
// e.g. (set R32:$dst, 0).
- if (P->isLeaf() && dynamic_cast<const IntInit*>(P->getLeafValue()))
+ if (P->isLeaf() && dynamic_cast<IntInit*>(P->getLeafValue()))
Size += 2;
// FIXME: This is a hack to statically increase the priority of patterns
Child->getType(0) != MVT::Other)
Size += getPatternSize(Child, CGP);
else if (Child->isLeaf()) {
- if (dynamic_cast<const IntInit*>(Child->getLeafValue()))
+ if (dynamic_cast<IntInit*>(Child->getLeafValue()))
Size += 5; // Matches a ConstantSDNode (+3) and a specific value (+2).
else if (Child->getComplexPatternInfo(CGP))
Size += getPatternSize(Child, CGP);
std::string PatternToMatch::getPredicateCheck() const {
std::string PredicateCheck;
for (unsigned i = 0, e = Predicates->getSize(); i != e; ++i) {
- if (const DefInit *Pred =
- dynamic_cast<const DefInit*>(Predicates->getElement(i))) {
+ if (DefInit *Pred = dynamic_cast<DefInit*>(Predicates->getElement(i))) {
Record *Def = Pred->getDef();
if (!Def->isSubClassOf("Predicate")) {
#ifndef NDEBUG
// The NodeToApply must be a leaf node that is a VT. OtherOperandNum must
// have an integer type that is smaller than the VT.
if (!NodeToApply->isLeaf() ||
- !dynamic_cast<const DefInit*>(NodeToApply->getLeafValue()) ||
- !static_cast<const DefInit*>(NodeToApply->getLeafValue())->getDef()
+ !dynamic_cast<DefInit*>(NodeToApply->getLeafValue()) ||
+ !static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef()
->isSubClassOf("ValueType"))
TP.error(N->getOperator()->getName() + " expects a VT operand!");
MVT::SimpleValueType VT =
- getValueType(static_cast<const DefInit*>(NodeToApply->getLeafValue())
- ->getDef());
+ getValueType(static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef());
EEVT::TypeSet TypeListTmp(VT, TP);
return PFRec->getOnlyTree()->getNumTypes();
// Get the result tree.
- const DagInit *Tree = Operator->getValueAsDag("Fragment");
+ DagInit *Tree = Operator->getValueAsDag("Fragment");
Record *Op = 0;
- if (Tree && dynamic_cast<const DefInit*>(Tree->getOperator()))
- Op = dynamic_cast<const DefInit*>(Tree->getOperator())->getDef();
+ if (Tree && dynamic_cast<DefInit*>(Tree->getOperator()))
+ Op = dynamic_cast<DefInit*>(Tree->getOperator())->getDef();
assert(Op && "Invalid Fragment");
return GetNumNodeResults(Op, CDP);
}
return false;
if (isLeaf()) {
- if (const DefInit *DI = dynamic_cast<const DefInit*>(getLeafValue())) {
- if (const DefInit *NDI = dynamic_cast<const DefInit*>(N->getLeafValue())) {
+ if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) {
+ if (DefInit *NDI = dynamic_cast<DefInit*>(N->getLeafValue())) {
return ((DI->getDef() == NDI->getDef())
&& (DepVars.find(getName()) == DepVars.end()
|| getName() == N->getName()));
for (unsigned i = 0, e = getNumChildren(); i != e; ++i) {
TreePatternNode *Child = getChild(i);
if (Child->isLeaf()) {
- const Init *Val = Child->getLeafValue();
- if (dynamic_cast<const DefInit*>(Val) &&
- static_cast<const DefInit*>(Val)->getDef()->getName() == "node") {
+ Init *Val = Child->getLeafValue();
+ if (dynamic_cast<DefInit*>(Val) &&
+ static_cast<DefInit*>(Val)->getDef()->getName() == "node") {
// We found a use of a formal argument, replace it with its value.
TreePatternNode *NewChild = ArgMap[Child->getName()];
assert(NewChild && "Couldn't find formal argument!");
return 0;
unsigned IID =
- dynamic_cast<const IntInit*>(getChild(0)->getLeafValue())->getValue();
+ dynamic_cast<IntInit*>(getChild(0)->getLeafValue())->getValue();
return &CDP.getIntrinsicInfo(IID);
}
TreePatternNode::getComplexPatternInfo(const CodeGenDAGPatterns &CGP) const {
if (!isLeaf()) return 0;
- const DefInit *DI = dynamic_cast<const DefInit*>(getLeafValue());
+ DefInit *DI = dynamic_cast<DefInit*>(getLeafValue());
if (DI && DI->getDef()->isSubClassOf("ComplexPattern"))
return &CGP.getComplexPattern(DI->getDef());
return 0;
bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
CodeGenDAGPatterns &CDP = TP.getDAGPatterns();
if (isLeaf()) {
- if (const DefInit *DI = dynamic_cast<const DefInit*>(getLeafValue())) {
+ if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) {
// If it's a regclass or something else known, include the type.
bool MadeChange = false;
for (unsigned i = 0, e = Types.size(); i != e; ++i)
return MadeChange;
}
- if (const IntInit *II = dynamic_cast<const IntInit*>(getLeafValue())) {
+ if (IntInit *II = dynamic_cast<IntInit*>(getLeafValue())) {
assert(Types.size() == 1 && "Invalid IntInit");
// Int inits are always integers. :)
static bool OnlyOnRHSOfCommutative(TreePatternNode *N) {
if (!N->isLeaf() && N->getOperator()->getName() == "imm")
return true;
- if (N->isLeaf() && dynamic_cast<const IntInit*>(N->getLeafValue()))
+ if (N->isLeaf() && dynamic_cast<IntInit*>(N->getLeafValue()))
return true;
return false;
}
// TreePattern implementation
//
-TreePattern::TreePattern(Record *TheRec, const ListInit *RawPat, bool isInput,
+TreePattern::TreePattern(Record *TheRec, ListInit *RawPat, bool isInput,
CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){
isInputPattern = isInput;
for (unsigned i = 0, e = RawPat->getSize(); i != e; ++i)
Trees.push_back(ParseTreePattern(RawPat->getElement(i), ""));
}
-TreePattern::TreePattern(Record *TheRec, const DagInit *Pat, bool isInput,
+TreePattern::TreePattern(Record *TheRec, DagInit *Pat, bool isInput,
CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){
isInputPattern = isInput;
Trees.push_back(ParseTreePattern(Pat, ""));
}
-TreePatternNode *TreePattern::ParseTreePattern(const Init *TheInit,
- StringRef OpName){
- if (const DefInit *DI = dynamic_cast<const DefInit*>(TheInit)) {
+TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){
+ if (DefInit *DI = dynamic_cast<DefInit*>(TheInit)) {
Record *R = DI->getDef();
// Direct reference to a leaf DagNode or PatFrag? Turn it into a
// TreePatternNode of its own. For example:
/// (foo GPR, imm) -> (foo GPR, (imm))
if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag"))
- return ParseTreePattern(DagInit::get(DI, "",
- std::vector<std::pair<const Init*, std::string> >()),
+ return ParseTreePattern(new DagInit(DI, "",
+ std::vector<std::pair<Init*, std::string> >()),
OpName);
// Input argument?
return Res;
}
- if (const IntInit *II = dynamic_cast<const IntInit*>(TheInit)) {
+ if (IntInit *II = dynamic_cast<IntInit*>(TheInit)) {
if (!OpName.empty())
error("Constant int argument should not have a name!");
return new TreePatternNode(II, 1);
}
- if (const BitsInit *BI = dynamic_cast<const BitsInit*>(TheInit)) {
+ if (BitsInit *BI = dynamic_cast<BitsInit*>(TheInit)) {
// Turn this into an IntInit.
- const Init *II = BI->convertInitializerTo(new IntRecTy());
- if (II == 0 || !dynamic_cast<const IntInit*>(II))
+ Init *II = BI->convertInitializerTo(new IntRecTy());
+ if (II == 0 || !dynamic_cast<IntInit*>(II))
error("Bits value must be constants!");
return ParseTreePattern(II, OpName);
}
- const DagInit *Dag = dynamic_cast<const DagInit*>(TheInit);
+ DagInit *Dag = dynamic_cast<DagInit*>(TheInit);
if (!Dag) {
TheInit->dump();
error("Pattern has unexpected init kind!");
}
- const DefInit *OpDef = dynamic_cast<const DefInit*>(Dag->getOperator());
+ DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator());
if (!OpDef) error("Pattern has unexpected operator type!");
Record *Operator = OpDef->getDef();
else // Otherwise, no chain.
Operator = getDAGPatterns().get_intrinsic_wo_chain_sdnode();
- TreePatternNode *IIDNode = new TreePatternNode(IntInit::get(IID), 1);
+ TreePatternNode *IIDNode = new TreePatternNode(new IntInit(IID), 1);
Children.insert(Children.begin(), IIDNode);
}
// us to match things like:
// def : Pat<(v1i64 (bitconvert(v2i32 DPR:$src))), (v1i64 DPR:$src)>;
if (Nodes[i] == Trees[0] && Nodes[i]->isLeaf()) {
- const DefInit *DI =
- dynamic_cast<const DefInit*>(Nodes[i]->getLeafValue());
+ DefInit *DI = dynamic_cast<DefInit*>(Nodes[i]->getLeafValue());
if (DI && (DI->getDef()->isSubClassOf("RegisterClass") ||
DI->getDef()->isSubClassOf("RegisterOperand")))
continue;
// First step, parse all of the fragments.
for (unsigned i = 0, e = Fragments.size(); i != e; ++i) {
- const DagInit *Tree = Fragments[i]->getValueAsDag("Fragment");
+ DagInit *Tree = Fragments[i]->getValueAsDag("Fragment");
TreePattern *P = new TreePattern(Fragments[i], Tree, true, *this);
PatternFragments[Fragments[i]] = P;
P->error("Cannot have unnamed 'node' values in pattern fragment!");
// Parse the operands list.
- const DagInit *OpsList = Fragments[i]->getValueAsDag("Operands");
- const DefInit *OpsOp = dynamic_cast<const DefInit*>(OpsList->getOperator());
+ DagInit *OpsList = Fragments[i]->getValueAsDag("Operands");
+ DefInit *OpsOp = dynamic_cast<DefInit*>(OpsList->getOperator());
// Special cases: ops == outs == ins. Different names are used to
// improve readability.
if (!OpsOp ||
// Copy over the arguments.
Args.clear();
for (unsigned j = 0, e = OpsList->getNumArgs(); j != e; ++j) {
- if (!dynamic_cast<const DefInit*>(OpsList->getArg(j)) ||
- static_cast<const DefInit*>(OpsList->getArg(j))->
+ if (!dynamic_cast<DefInit*>(OpsList->getArg(j)) ||
+ static_cast<DefInit*>(OpsList->getArg(j))->
getDef()->getName() != "node")
P->error("Operands list should all be 'node' values.");
if (OpsList->getArgName(j).empty())
// Find some SDNode.
assert(!SDNodes.empty() && "No SDNodes parsed?");
- const Init *SomeSDNode = DefInit::get(SDNodes.begin()->first);
+ Init *SomeSDNode = new DefInit(SDNodes.begin()->first);
for (unsigned iter = 0; iter != 2; ++iter) {
for (unsigned i = 0, e = DefaultOps[iter].size(); i != e; ++i) {
- const DagInit *DefaultInfo = DefaultOps[iter][i]->getValueAsDag("DefaultOps");
+ DagInit *DefaultInfo = DefaultOps[iter][i]->getValueAsDag("DefaultOps");
// Clone the DefaultInfo dag node, changing the operator from 'ops' to
// SomeSDnode so that we can parse this.
- std::vector<std::pair<const Init*, std::string> > Ops;
+ std::vector<std::pair<Init*, std::string> > Ops;
for (unsigned op = 0, e = DefaultInfo->getNumArgs(); op != e; ++op)
Ops.push_back(std::make_pair(DefaultInfo->getArg(op),
DefaultInfo->getArgName(op)));
- const DagInit *DI = DagInit::get(SomeSDNode, "", Ops);
+ DagInit *DI = new DagInit(SomeSDNode, "", Ops);
// Create a TreePattern to parse this.
TreePattern P(DefaultOps[iter][i], DI, false, *this);
// No name -> not interesting.
if (Pat->getName().empty()) {
if (Pat->isLeaf()) {
- const DefInit *DI = dynamic_cast<const DefInit*>(Pat->getLeafValue());
+ DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue());
if (DI && (DI->getDef()->isSubClassOf("RegisterClass") ||
DI->getDef()->isSubClassOf("RegisterOperand")))
I->error("Input " + DI->getDef()->getName() + " must be named!");
Record *Rec;
if (Pat->isLeaf()) {
- const DefInit *DI = dynamic_cast<const DefInit*>(Pat->getLeafValue());
+ DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue());
if (!DI) I->error("Input $" + Pat->getName() + " must be an identifier!");
Rec = DI->getDef();
} else {
}
Record *SlotRec;
if (Slot->isLeaf()) {
- SlotRec = dynamic_cast<const DefInit*>(Slot->getLeafValue())->getDef();
+ SlotRec = dynamic_cast<DefInit*>(Slot->getLeafValue())->getDef();
} else {
assert(Slot->getNumChildren() == 0 && "can't be a use with children!");
SlotRec = Slot->getOperator();
if (!Dest->isLeaf())
I->error("implicitly defined value should be a register!");
- const DefInit *Val = dynamic_cast<const DefInit*>(Dest->getLeafValue());
+ DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue());
if (!Val || !Val->getDef()->isSubClassOf("Register"))
I->error("implicitly defined value should be a register!");
InstImpResults.push_back(Val->getDef());
if (!Dest->isLeaf())
I->error("set destination should be a register!");
- const DefInit *Val = dynamic_cast<const DefInit*>(Dest->getLeafValue());
+ DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue());
if (!Val)
I->error("set destination should be a register!");
return false;
const TreePatternNode *N0 = N->getChild(0);
- if (!N0->isLeaf() || !dynamic_cast<const DefInit*>(N0->getLeafValue()))
+ if (!N0->isLeaf() || !dynamic_cast<DefInit*>(N0->getLeafValue()))
return false;
const TreePatternNode *N1 = N->getChild(1);
void AnalyzeNode(const TreePatternNode *N) {
if (N->isLeaf()) {
- if (const DefInit *DI = dynamic_cast<const DefInit*>(N->getLeafValue())) {
+ if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) {
Record *LeafRec = DI->getDef();
// Handle ComplexPattern leaves.
if (LeafRec->isSubClassOf("ComplexPattern")) {
std::vector<Record*> Instrs = Records.getAllDerivedDefinitions("Instruction");
for (unsigned i = 0, e = Instrs.size(); i != e; ++i) {
- const ListInit *LI = 0;
+ ListInit *LI = 0;
- if (dynamic_cast<const ListInit*>(Instrs[i]->getValueInit("Pattern")))
+ if (dynamic_cast<ListInit*>(Instrs[i]->getValueInit("Pattern")))
LI = Instrs[i]->getValueAsListInit("Pattern");
// If there is no pattern, only collect minimal information about the
if (i == 0)
Res0Node = RNode;
- Record *R = dynamic_cast<const DefInit*>(RNode->getLeafValue())->getDef();
+ Record *R = dynamic_cast<DefInit*>(RNode->getLeafValue())->getDef();
if (R == 0)
I->error("Operand $" + OpName + " should be a set destination: all "
"outputs must occur before inputs in operand list!");
InstInputsCheck.erase(OpName); // It occurred, remove from map.
if (InVal->isLeaf() &&
- dynamic_cast<const DefInit*>(InVal->getLeafValue())) {
- Record *InRec = static_cast<const DefInit*>(InVal->getLeafValue())->getDef();
+ dynamic_cast<DefInit*>(InVal->getLeafValue())) {
+ Record *InRec = static_cast<DefInit*>(InVal->getLeafValue())->getDef();
if (Op.Rec != InRec && !InRec->isSubClassOf("ComplexPattern"))
I->error("Operand $" + OpName + "'s register class disagrees"
" between the operand and pattern");
for (unsigned i = 0, e = Patterns.size(); i != e; ++i) {
Record *CurPattern = Patterns[i];
- const DagInit *Tree = CurPattern->getValueAsDag("PatternToMatch");
+ DagInit *Tree = CurPattern->getValueAsDag("PatternToMatch");
TreePattern *Pattern = new TreePattern(CurPattern, Tree, true, *this);
// Inline pattern fragments into it.
Pattern->InlinePatternFragments();
- const ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs");
+ ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs");
if (LI->getSize() == 0) continue; // no pattern.
// Parse the instruction.
for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) {
TreePatternNode *Child = N->getChild(i);
if (Child->isLeaf())
- if (const DefInit *DI =
- dynamic_cast<const DefInit*>(Child->getLeafValue())) {
+ if (DefInit *DI = dynamic_cast<DefInit*>(Child->getLeafValue())) {
Record *RR = DI->getDef();
if (RR->isSubClassOf("Register"))
continue;
namespace llvm {
class Record;
- class Init;
+ struct Init;
class ListInit;
class DagInit;
class SDNodeInfo;
/// Val - The init value (e.g. the "GPRC" record, or "7") for a leaf.
///
- const Init *Val;
+ Init *Val;
/// Name - The name given to this node with the :$foo notation.
///
: Operator(Op), Val(0), TransformFn(0), Children(Ch) {
Types.resize(NumResults);
}
- TreePatternNode(const Init *val, unsigned NumResults) // leaf ctor
+ TreePatternNode(Init *val, unsigned NumResults) // leaf ctor
: Operator(0), Val(val), TransformFn(0) {
Types.resize(NumResults);
}
return Types[ResNo].isDynamicallyResolved();
}
- const Init *getLeafValue() const { assert(isLeaf()); return Val; }
+ Init *getLeafValue() const { assert(isLeaf()); return Val; }
Record *getOperator() const { assert(!isLeaf()); return Operator; }
unsigned getNumChildren() const { return Children.size(); }
/// TreePattern constructor - Parse the specified DagInits into the
/// current record.
- TreePattern(Record *TheRec, const ListInit *RawPat, bool isInput,
+ TreePattern(Record *TheRec, ListInit *RawPat, bool isInput,
CodeGenDAGPatterns &ise);
- TreePattern(Record *TheRec, const DagInit *Pat, bool isInput,
+ TreePattern(Record *TheRec, DagInit *Pat, bool isInput,
CodeGenDAGPatterns &ise);
TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput,
CodeGenDAGPatterns &ise);
void dump() const;
private:
- TreePatternNode *ParseTreePattern(const Init *DI, StringRef OpName);
+ TreePatternNode *ParseTreePattern(Init *DI, StringRef OpName);
void ComputeNamedNodes();
void ComputeNamedNodes(TreePatternNode *N);
};
/// processed to produce isel.
class PatternToMatch {
public:
- PatternToMatch(Record *srcrecord, const ListInit *preds,
+ PatternToMatch(Record *srcrecord, ListInit *preds,
TreePatternNode *src, TreePatternNode *dst,
const std::vector<Record*> &dstregs,
unsigned complexity, unsigned uid)
Dstregs(dstregs), AddedComplexity(complexity), ID(uid) {}
Record *SrcRecord; // Originating Record for the pattern.
- const ListInit *Predicates; // Top level predicate conditions to match.
+ ListInit *Predicates; // Top level predicate conditions to match.
TreePatternNode *SrcPattern; // Source pattern to match.
TreePatternNode *DstPattern; // Resulting pattern.
std::vector<Record*> Dstregs; // Physical register defs being matched.
unsigned ID; // Unique ID for the record.
Record *getSrcRecord() const { return SrcRecord; }
- const ListInit *getPredicates() const { return Predicates; }
+ ListInit *getPredicates() const { return Predicates; }
TreePatternNode *getSrcPattern() const { return SrcPattern; }
TreePatternNode *getDstPattern() const { return DstPattern; }
const std::vector<Record*> &getDstRegs() const { return Dstregs; }
hasOptionalDef = false;
isVariadic = false;
- const DagInit *OutDI = R->getValueAsDag("OutOperandList");
+ DagInit *OutDI = R->getValueAsDag("OutOperandList");
- if (const DefInit *Init =
- dynamic_cast<const DefInit*>(OutDI->getOperator())) {
+ if (DefInit *Init = dynamic_cast<DefInit*>(OutDI->getOperator())) {
if (Init->getDef()->getName() != "outs")
throw R->getName() + ": invalid def name for output list: use 'outs'";
} else
NumDefs = OutDI->getNumArgs();
- const DagInit *InDI = R->getValueAsDag("InOperandList");
- if (const DefInit *Init = dynamic_cast<const DefInit*>(InDI->getOperator())) {
+ DagInit *InDI = R->getValueAsDag("InOperandList");
+ if (DefInit *Init = dynamic_cast<DefInit*>(InDI->getOperator())) {
if (Init->getDef()->getName() != "ins")
throw R->getName() + ": invalid def name for input list: use 'ins'";
} else
unsigned MIOperandNo = 0;
std::set<std::string> OperandNames;
for (unsigned i = 0, e = InDI->getNumArgs()+OutDI->getNumArgs(); i != e; ++i){
- const Init *ArgInit;
+ Init *ArgInit;
std::string ArgName;
if (i < NumDefs) {
ArgInit = OutDI->getArg(i);
ArgName = InDI->getArgName(i-NumDefs);
}
- const DefInit *Arg = dynamic_cast<const DefInit*>(ArgInit);
+ DefInit *Arg = dynamic_cast<DefInit*>(ArgInit);
if (!Arg)
throw "Illegal operand for the '" + R->getName() + "' instruction!";
std::string PrintMethod = "printOperand";
std::string EncoderMethod;
unsigned NumOps = 1;
- const DagInit *MIOpInfo = 0;
+ DagInit *MIOpInfo = 0;
if (Rec->isSubClassOf("RegisterOperand")) {
PrintMethod = Rec->getValueAsString("PrintMethod");
} else if (Rec->isSubClassOf("Operand")) {
MIOpInfo = Rec->getValueAsDag("MIOperandInfo");
// Verify that MIOpInfo has an 'ops' root value.
- if (!dynamic_cast<const DefInit*>(MIOpInfo->getOperator()) ||
- dynamic_cast<const DefInit*>(MIOpInfo->getOperator())
+ if (!dynamic_cast<DefInit*>(MIOpInfo->getOperator()) ||
+ dynamic_cast<DefInit*>(MIOpInfo->getOperator())
->getDef()->getName() != "ops")
throw "Bad value for MIOperandInfo in operand '" + Rec->getName() +
"'\n";
}
// Find the suboperand number involved.
- const DagInit *MIOpInfo = OperandList[OpIdx].MIOperandInfo;
+ DagInit *MIOpInfo = OperandList[OpIdx].MIOperandInfo;
if (MIOpInfo == 0)
throw TheDef->getName() + ": unknown suboperand name in '" + Op + "'";
/// constructor. It checks if an argument in an InstAlias pattern matches
/// the corresponding operand of the instruction. It returns true on a
/// successful match, with ResOp set to the result operand to be used.
-bool CodeGenInstAlias::tryAliasOpMatch(const DagInit *Result,
- unsigned AliasOpNo,
+bool CodeGenInstAlias::tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo,
Record *InstOpRec, bool hasSubOps,
SMLoc Loc, CodeGenTarget &T,
ResultOperand &ResOp) {
- const Init *Arg = Result->getArg(AliasOpNo);
- const DefInit *ADI = dynamic_cast<const DefInit*>(Arg);
+ Init *Arg = Result->getArg(AliasOpNo);
+ DefInit *ADI = dynamic_cast<DefInit*>(Arg);
if (ADI && ADI->getDef() == InstOpRec) {
// If the operand is a record, it must have a name, and the record type
return true;
}
- if (const IntInit *II = dynamic_cast<const IntInit*>(Arg)) {
+ if (IntInit *II = dynamic_cast<IntInit*>(Arg)) {
if (hasSubOps || !InstOpRec->isSubClassOf("Operand"))
return false;
// Integer arguments can't have names.
Result = R->getValueAsDag("ResultInst");
// Verify that the root of the result is an instruction.
- const DefInit *DI = dynamic_cast<const DefInit*>(Result->getOperator());
+ DefInit *DI = dynamic_cast<DefInit*>(Result->getOperator());
if (DI == 0 || !DI->getDef()->isSubClassOf("Instruction"))
throw TGError(R->getLoc(), "result of inst alias should be an instruction");
// the same class.
StringMap<Record*> NameClass;
for (unsigned i = 0, e = Result->getNumArgs(); i != e; ++i) {
- const DefInit *ADI = dynamic_cast<const DefInit*>(Result->getArg(i));
+ DefInit *ADI = dynamic_cast<DefInit*>(Result->getArg(i));
if (!ADI || Result->getArgName(i).empty())
continue;
// Verify we don't have something like: (someinst GR16:$foo, GR32:$foo)
// If the argument did not match the instruction operand, and the operand
// is composed of multiple suboperands, try matching the suboperands.
if (NumSubOps > 1) {
- const DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo;
+ DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo;
for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) {
if (AliasOpNo >= Result->getNumArgs())
throw TGError(R->getLoc(), "not enough arguments for instruction!");
- Record *SubRec =
- dynamic_cast<const DefInit*>(MIOI->getArg(SubOp))->getDef();
+ Record *SubRec = dynamic_cast<DefInit*>(MIOI->getArg(SubOp))->getDef();
if (tryAliasOpMatch(Result, AliasOpNo, SubRec, false,
R->getLoc(), T, ResOp)) {
ResultOperands.push_back(ResOp);
/// MIOperandInfo - Default MI operand type. Note an operand may be made
/// up of multiple MI operands.
- const DagInit *MIOperandInfo;
+ DagInit *MIOperandInfo;
/// Constraint info for this operand. This operand can have pieces, so we
/// track constraint info for each.
OperandInfo(Record *R, const std::string &N, const std::string &PMN,
const std::string &EMN, unsigned MION, unsigned MINO,
- const DagInit *MIOI)
+ DagInit *MIOI)
: Rec(R), Name(N), PrinterMethodName(PMN), EncoderMethodName(EMN),
MIOperandNo(MION), MINumOperands(MINO), MIOperandInfo(MIOI) {}
std::string AsmString;
/// Result - The result instruction.
- const DagInit *Result;
+ DagInit *Result;
/// ResultInst - The instruction generated by the alias (decoded from
/// Result).
CodeGenInstAlias(Record *R, CodeGenTarget &T);
- bool tryAliasOpMatch(const DagInit *Result, unsigned AliasOpNo,
+ bool tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo,
Record *InstOpRec, bool hasSubOps, SMLoc Loc,
CodeGenTarget &T, ResultOperand &ResOp);
};
}
// Process the composites.
- const ListInit *Comps = TheDef->getValueAsListInit("CompositeIndices");
+ ListInit *Comps = TheDef->getValueAsListInit("CompositeIndices");
for (unsigned i = 0, e = Comps->size(); i != e; ++i) {
- const DagInit *Pat = dynamic_cast<const DagInit*>(Comps->getElement(i));
+ DagInit *Pat = dynamic_cast<DagInit*>(Comps->getElement(i));
if (!Pat)
throw TGError(TheDef->getLoc(), "Invalid dag '" +
Comps->getElement(i)->getAsString() +
"' in CompositeIndices");
- const DefInit *BaseIdxInit =
- dynamic_cast<const DefInit*>(Pat->getOperator());
+ DefInit *BaseIdxInit = dynamic_cast<DefInit*>(Pat->getOperator());
if (!BaseIdxInit || !BaseIdxInit->getDef()->isSubClassOf("SubRegIndex"))
throw TGError(TheDef->getLoc(), "Invalid SubClassIndex in " +
Pat->getAsString());
CodeGenRegister *R2 = this;
for (DagInit::const_arg_iterator di = Pat->arg_begin(),
de = Pat->arg_end(); di != de; ++di) {
- const DefInit *IdxInit = dynamic_cast<const DefInit*>(*di);
+ DefInit *IdxInit = dynamic_cast<DefInit*>(*di);
if (!IdxInit || !IdxInit->getDef()->isSubClassOf("SubRegIndex"))
throw TGError(TheDef->getLoc(), "Invalid SubClassIndex in " +
Pat->getAsString());
void expand(SetTheory &ST, Record *Def, SetTheory::RecSet &Elts) {
std::vector<Record*> Indices = Def->getValueAsListOfDefs("SubRegIndices");
unsigned Dim = Indices.size();
- const ListInit *SubRegs = Def->getValueAsListInit("SubRegs");
+ ListInit *SubRegs = Def->getValueAsListInit("SubRegs");
if (Dim != SubRegs->getSize())
throw TGError(Def->getLoc(), "SubRegIndices and SubRegs size mismatch");
if (Dim < 2)
// Precompute some types.
Record *RegisterCl = Def->getRecords().getClass("Register");
RecTy *RegisterRecTy = new RecordRecTy(RegisterCl);
- const StringInit *BlankName = StringInit::get("");
+ StringInit *BlankName = new StringInit("");
// Zip them up.
for (unsigned n = 0; n != Length; ++n) {
std::string Name;
Record *Proto = Lists[0][n];
- std::vector<const Init*> Tuple;
+ std::vector<Init*> Tuple;
unsigned CostPerUse = 0;
for (unsigned i = 0; i != Dim; ++i) {
Record *Reg = Lists[i][n];
if (i) Name += '_';
Name += Reg->getName();
- Tuple.push_back(DefInit::get(Reg));
+ Tuple.push_back(new DefInit(Reg));
CostPerUse = std::max(CostPerUse,
unsigned(Reg->getValueAsInt("CostPerUse")));
}
// Replace the sub-register list with Tuple.
if (RV.getName() == "SubRegs")
- RV.setValue(ListInit::get(Tuple, RegisterRecTy));
+ RV.setValue(new ListInit(Tuple, RegisterRecTy));
// Provide a blank AsmName. MC hacks are required anyway.
if (RV.getName() == "AsmName")
// CostPerUse is aggregated from all Tuple members.
if (RV.getName() == "CostPerUse")
- RV.setValue(IntInit::get(CostPerUse));
+ RV.setValue(new IntInit(CostPerUse));
// Copy fields from the RegisterTuples def.
if (RV.getName() == "SubRegIndices" ||
Members.insert(RegBank.getReg((*Elements)[i]));
// Alternative allocation orders may be subsets.
- const ListInit *Alts = R->getValueAsListInit("AltOrders");
+ ListInit *Alts = R->getValueAsListInit("AltOrders");
AltOrders.resize(Alts->size());
SetTheory::RecSet Order;
for (unsigned i = 0, e = Alts->size(); i != e; ++i) {
}
// SubRegClasses is a list<dag> containing (RC, subregindex, ...) dags.
- const ListInit *SRC = R->getValueAsListInit("SubRegClasses");
+ ListInit *SRC = R->getValueAsListInit("SubRegClasses");
for (ListInit::const_iterator i = SRC->begin(), e = SRC->end(); i != e; ++i) {
- const DagInit *DAG = dynamic_cast<const DagInit*>(*i);
+ DagInit *DAG = dynamic_cast<DagInit*>(*i);
if (!DAG) throw "SubRegClasses must contain DAGs";
- const DefInit *DAGOp = dynamic_cast<const DefInit*>(DAG->getOperator());
+ DefInit *DAGOp = dynamic_cast<DefInit*>(DAG->getOperator());
Record *RCRec;
if (!DAGOp || !(RCRec = DAGOp->getDef())->isSubClassOf("RegisterClass"))
throw "Operator '" + DAG->getOperator()->getAsString() +
// Iterate over args, all SubRegIndex instances.
for (DagInit::const_arg_iterator ai = DAG->arg_begin(), ae = DAG->arg_end();
ai != ae; ++ai) {
- const DefInit *Idx = dynamic_cast<const DefInit*>(*ai);
+ DefInit *Idx = dynamic_cast<DefInit*>(*ai);
Record *IdxRec;
if (!Idx || !(IdxRec = Idx->getDef())->isSubClassOf("SubRegIndex"))
throw "Argument '" + (*ai)->getAsString() +
// Parse the list of return types.
std::vector<MVT::SimpleValueType> OverloadedVTs;
- const ListInit *TypeList = R->getValueAsListInit("RetTypes");
+ ListInit *TypeList = R->getValueAsListInit("RetTypes");
for (unsigned i = 0, e = TypeList->getSize(); i != e; ++i) {
Record *TyEl = TypeList->getElementAsRecord(i);
assert(TyEl->isSubClassOf("LLVMType") && "Expected a type!");
}
// Parse the intrinsic properties.
- const ListInit *PropList = R->getValueAsListInit("Properties");
+ ListInit *PropList = R->getValueAsListInit("Properties");
for (unsigned i = 0, e = PropList->getSize(); i != e; ++i) {
Record *Property = PropList->getElementAsRecord(i);
assert(Property->isSubClassOf("IntrinsicProperty") &&
assert(N->isLeaf() && "Not a leaf?");
// Direct match against an integer constant.
- if (const IntInit *II = dynamic_cast<const IntInit*>(N->getLeafValue())) {
+ if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) {
// If this is the root of the dag we're matching, we emit a redundant opcode
// check to ensure that this gets folded into the normal top-level
// OpcodeSwitch.
return AddMatcher(new CheckIntegerMatcher(II->getValue()));
}
- const DefInit *DI = dynamic_cast<const DefInit*>(N->getLeafValue());
+ DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue());
if (DI == 0) {
errs() << "Unknown leaf kind: " << *DI << "\n";
abort();
N->getOperator()->getName() == "or") &&
N->getChild(1)->isLeaf() && N->getChild(1)->getPredicateFns().empty() &&
N->getPredicateFns().empty()) {
- if (const IntInit *II =
- dynamic_cast<const IntInit*>(N->getChild(1)->getLeafValue())) {
+ if (IntInit *II = dynamic_cast<IntInit*>(N->getChild(1)->getLeafValue())) {
if (!isPowerOf2_32(II->getValue())) { // Don't bother with single bits.
// If this is at the root of the pattern, we emit a redundant
// CheckOpcode so that the following checks get factored properly under
--RecNodeEntry; // Entries in VariableMap are biased.
const ComplexPattern &CP =
- CGP.getComplexPattern(((const DefInit*)N->getLeafValue())->getDef());
+ CGP.getComplexPattern(((DefInit*)N->getLeafValue())->getDef());
// Emit a CheckComplexPat operation, which does the match (aborting if it
// fails) and pushes the matched operands onto the recorded nodes list.
SmallVectorImpl<unsigned> &ResultOps) {
assert(N->isLeaf() && "Must be a leaf");
- if (const IntInit *II = dynamic_cast<const IntInit*>(N->getLeafValue())) {
+ if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) {
AddMatcher(new EmitIntegerMatcher(II->getValue(), N->getType(0)));
ResultOps.push_back(NextRecordedOperandNo++);
return;
}
// If this is an explicit register reference, handle it.
- if (const DefInit *DI = dynamic_cast<const DefInit*>(N->getLeafValue())) {
+ if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) {
Record *Def = DI->getDef();
if (Def->isSubClassOf("Register")) {
const CodeGenRegister *Reg =
if (Op->getType(0) != VT)
return false;
- const DefInit *OpDI = dynamic_cast<const DefInit*>(Op->getLeafValue());
+ DefInit *OpDI = dynamic_cast<DefInit*>(Op->getLeafValue());
if (!OpDI)
return false;
Record *OpLeafRec = OpDI->getDef();
if (!Op->isLeaf())
return PhysReg;
- const DefInit *OpDI = dynamic_cast<const DefInit*>(Op->getLeafValue());
+ DefInit *OpDI = dynamic_cast<DefInit*>(Op->getLeafValue());
Record *OpLeafRec = OpDI->getDef();
if (!OpLeafRec->isSubClassOf("Register"))
return PhysReg;
- PhysReg += static_cast<const StringInit*>(OpLeafRec->getValue( \
+ PhysReg += static_cast<StringInit*>(OpLeafRec->getValue( \
"Namespace")->getValue())->getValue();
PhysReg += "::";
PhysReg += Target.getRegBank().getReg(OpLeafRec)->getName();
// a bit too complicated for now.
if (!Dst->getChild(1)->isLeaf()) continue;
- const DefInit *SR = dynamic_cast<const DefInit*>(Dst->getChild(1)->getLeafValue());
+ DefInit *SR = dynamic_cast<DefInit*>(Dst->getChild(1)->getLeafValue());
if (SR)
SubRegNo = getQualifiedName(SR->getDef());
else
static int Value(bit_value_t V) {
return ValueNotSet(V) ? -1 : (V == BIT_FALSE ? 0 : 1);
}
-static bit_value_t bitFromBits(const BitsInit &bits, unsigned index) {
- if (const BitInit *bit = dynamic_cast<const BitInit*>(bits.getBit(index)))
+static bit_value_t bitFromBits(BitsInit &bits, unsigned index) {
+ if (BitInit *bit = dynamic_cast<BitInit*>(bits.getBit(index)))
return bit->getValue() ? BIT_TRUE : BIT_FALSE;
// The bit is uninitialized.
return BIT_UNSET;
}
// Prints the bit value for each position.
-static void dumpBits(raw_ostream &o, const BitsInit &bits) {
+static void dumpBits(raw_ostream &o, BitsInit &bits) {
unsigned index;
for (index = bits.getNumBits(); index > 0; index--) {
}
}
-static const BitsInit &getBitsField(const Record &def, const char *str) {
- const BitsInit *bits = def.getValueAsBitsInit(str);
+static BitsInit &getBitsField(const Record &def, const char *str) {
+ BitsInit *bits = def.getValueAsBitsInit(str);
return *bits;
}
protected:
// Populates the insn given the uid.
void insnWithID(insn_t &Insn, unsigned Opcode) const {
- const BitsInit &Bits =
- getBitsField(*AllInstructions[Opcode]->TheDef, "Inst");
+ BitsInit &Bits = getBitsField(*AllInstructions[Opcode]->TheDef, "Inst");
for (unsigned i = 0; i < BIT_WIDTH; ++i)
Insn[i] = bitFromBits(Bits, i);
Def.getValueAsBit("isCodeGenOnly"))
return false;
- const BitsInit &Bits = getBitsField(Def, "Inst");
+ BitsInit &Bits = getBitsField(Def, "Inst");
if (Bits.allInComplete()) return false;
std::vector<OperandInfo> InsnOperands;
// Gather the outputs/inputs of the instruction, so we can find their
// positions in the encoding. This assumes for now that they appear in the
// MCInst in the order that they're listed.
- std::vector<std::pair<const Init*, std::string> > InOutOperands;
- const DagInit *Out = Def.getValueAsDag("OutOperandList");
- const DagInit *In = Def.getValueAsDag("InOperandList");
+ std::vector<std::pair<Init*, std::string> > InOutOperands;
+ DagInit *Out = Def.getValueAsDag("OutOperandList");
+ DagInit *In = Def.getValueAsDag("InOperandList");
for (unsigned i = 0; i < Out->getNumArgs(); ++i)
InOutOperands.push_back(std::make_pair(Out->getArg(i), Out->getArgName(i)));
for (unsigned i = 0; i < In->getNumArgs(); ++i)
InOutOperands.push_back(std::make_pair(In->getArg(i), In->getArgName(i)));
// For each operand, see if we can figure out where it is encoded.
- for (std::vector<std::pair<const Init*, std::string> >::iterator
+ for (std::vector<std::pair<Init*, std::string> >::iterator
NI = InOutOperands.begin(), NE = InOutOperands.end(); NI != NE; ++NI) {
unsigned PrevBit = ~0;
unsigned Base = ~0;
std::string Decoder = "";
for (unsigned bi = 0; bi < Bits.getNumBits(); ++bi) {
- const VarBitInit *BI = dynamic_cast<const VarBitInit*>(Bits.getBit(bi));
+ VarBitInit *BI = dynamic_cast<VarBitInit*>(Bits.getBit(bi));
if (!BI) continue;
- const VarInit *Var = dynamic_cast<const VarInit*>(BI->getVariable());
+ VarInit *Var = dynamic_cast<VarInit*>(BI->getVariable());
assert(Var);
unsigned CurrBit = BI->getBitNum();
if (Var->getName() != NI->second) continue;
// for decoding register classes.
// FIXME: This need to be extended to handle instructions with custom
// decoder methods, and operands with (simple) MIOperandInfo's.
- const TypedInit *TI = dynamic_cast<const TypedInit*>(NI->first);
+ TypedInit *TI = dynamic_cast<TypedInit*>(NI->first);
RecordRecTy *Type = dynamic_cast<RecordRecTy*>(TI->getType());
Record *TypeRecord = Type->getRecord();
bool isReg = false;
}
RecordVal *DecoderString = TypeRecord->getValue("DecoderMethod");
- const StringInit *String = DecoderString ?
- dynamic_cast<const StringInit*>(DecoderString->getValue()) :
+ StringInit *String = DecoderString ?
+ dynamic_cast<StringInit*>(DecoderString->getValue()) :
0;
if (!isReg && String && String->getValue() != "")
Decoder = String->getValue();
// registers in their multi-operand operands. It may also be an anonymous
// operand, which has a single operand, but no declared class for the
// operand.
- const DagInit *MIOI = Inst.Operands[i].MIOperandInfo;
+ DagInit *MIOI = Inst.Operands[i].MIOperandInfo;
if (!MIOI || MIOI->getNumArgs() == 0) {
// Single, anonymous, operand.
for (unsigned j = 0, e = Inst.Operands[i].MINumOperands; j != e; ++j) {
OperandList.push_back(Inst.Operands[i]);
- Record *OpR = dynamic_cast<const DefInit*>(MIOI->getArg(j))->getDef();
+ Record *OpR = dynamic_cast<DefInit*>(MIOI->getArg(j))->getDef();
OperandList.back().Rec = OpR;
}
}
if (Inst.hasExtraDefRegAllocReq) OS << "|(1<<MCID::ExtraDefRegAllocReq)";
// Emit all of the target-specific flags...
- const BitsInit *TSF = Inst.TheDef->getValueAsBitsInit("TSFlags");
+ BitsInit *TSF = Inst.TheDef->getValueAsBitsInit("TSFlags");
if (!TSF) throw "no TSFlags?";
uint64_t Value = 0;
for (unsigned i = 0, e = TSF->getNumBits(); i != e; ++i) {
- if (const BitInit *Bit = dynamic_cast<const BitInit*>(TSF->getBit(i)))
+ if (BitInit *Bit = dynamic_cast<BitInit*>(TSF->getBit(i)))
Value |= uint64_t(Bit->getValue()) << i;
else
throw "Invalid TSFlags bit in " + Inst.TheDef->getName();
unsigned Flags;
std::string Help;
unsigned MultiVal;
- const Init* InitVal;
+ Init* InitVal;
OptionDescription(OptionType::OptionType t = OptionType::Switch,
const std::string& n = "",
}
template <class FunctionObject>
-void InvokeDagInitHandler(FunctionObject* Obj, const Init* I) {
+void InvokeDagInitHandler(FunctionObject* Obj, Init* I) {
typedef void (FunctionObject::*Handler) (const DagInit&);
const DagInit& Dag = InitPtrToDag(I);
/// operator() - Just forwards to the corresponding property
/// handler.
- void operator() (const Init* I) {
+ void operator() (Init* I) {
InvokeDagInitHandler(this, I);
}
void onInit (const DagInit& d) {
CheckNumberOfArguments(d, 1);
- const Init* i = d.getArg(0);
+ Init* i = d.getArg(0);
const std::string& str = i->getAsString();
- bool correct = optDesc_.isParameter() && dynamic_cast<const StringInit*>(i);
+ bool correct = optDesc_.isParameter() && dynamic_cast<StringInit*>(i);
correct |= (optDesc_.isSwitch() && (str == "true" || str == "false"));
if (!correct)
for (RecordVector::const_iterator B = V.begin(), E = V.end(); B!=E; ++B)
{
// Throws an exception if the value does not exist.
- const ListInit* PropList = (*B)->getValueAsListInit("options");
+ ListInit* PropList = (*B)->getValueAsListInit("options");
// For every option description in this list: invoke AddOption.
std::for_each(PropList->begin(), PropList->end(), AddOption(OptDescs));
struct ToolDescription : public RefCountedBase<ToolDescription> {
std::string Name;
- const Init* CmdLine;
- const Init* Actions;
+ Init* CmdLine;
+ Init* Actions;
StrVector InLanguage;
std::string InFileOption;
std::string OutFileOption;
}
}
- void operator() (const Init* I) {
+ void operator() (Init* I) {
InvokeDagInitHandler(this, I);
}
void onActions (const DagInit& d) {
CheckNumberOfArguments(d, 1);
- const Init* Case = d.getArg(0);
+ Init* Case = d.getArg(0);
if (typeid(*Case) != typeid(DagInit) ||
- GetOperatorName(static_cast<const DagInit&>(*Case)) != "case")
+ GetOperatorName(static_cast<DagInit&>(*Case)) != "case")
throw "The argument to (actions) should be a 'case' construct!";
toolDesc_.Actions = Case;
}
isReallyJoin = true;
}
else {
- const Init* I = d.getArg(0);
+ 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.
- const ListInit* PropList = T->getValueAsListInit("properties");
+ 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) {
- const Init* arg = *B;
+ Init* arg = *B;
if (!even)
{
}
else
{
- if (dynamic_cast<const DagInit*>(arg)
- && GetOperatorName(static_cast<const DagInit&>(*arg)) == "case") {
+ if (dynamic_cast<DagInit*>(arg)
+ && GetOperatorName(static_cast<DagInit&>(*arg)) == "case") {
// Nested 'case'.
WalkCase(arg, TestCallback, StatementCallback, IndentLevel + Indent1);
}
ActionName == "parameter_equals" || ActionName == "element_in_list") {
CheckNumberOfArguments(Stmt, 1);
- const Init* Arg = Stmt.getArg(0);
+ Init* Arg = Stmt.getArg(0);
if (typeid(*Arg) == typeid(StringInit))
OptionNames_.insert(InitPtrToString(Arg));
}
ActionName == "any_not_empty" || ActionName == "any_empty" ||
ActionName == "not_empty" || ActionName == "empty") {
for (unsigned i = 0, NumArgs = Stmt.getNumArgs(); i < NumArgs; ++i) {
- const Init* Arg = Stmt.getArg(i);
+ Init* Arg = Stmt.getArg(i);
if (typeid(*Arg) == typeid(StringInit))
OptionNames_.insert(InitPtrToString(Arg));
}
for (RecordVector::const_iterator B = OptionPreprocessors.begin(),
E = OptionPreprocessors.end(); B!=E; ++B) {
- const DagInit* Case = (*B)->getValueAsDag("preprocessor");
+ DagInit* Case = (*B)->getValueAsDag("preprocessor");
EmitCaseConstructHandler(Case, Indent1,
EmitPreprocessOptionsCallback(OptDecs),
false, OptDecs, O);
}
}
- void operator() (const Init* I) {
+ void operator() (Init* I) {
InvokeDagInitHandler(this, I);
}
CheckNumberOfArguments(d, 2);
const std::string& Lang = InitPtrToString(d.getArg(0));
- const Init* Suffixes = d.getArg(1);
+ Init* Suffixes = d.getArg(1);
// Second argument to lang_to_suffixes is either a single string...
if (typeid(*Suffixes) == typeid(StringInit)) {
// Call DoEmitPopulateLanguageMap.
for (RecordVector::const_iterator B = LangMaps.begin(),
E = LangMaps.end(); B!=E; ++B) {
- const ListInit* LangMap = (*B)->getValueAsListInit("map");
+ ListInit* LangMap = (*B)->getValueAsListInit("map");
std::for_each(LangMap->begin(), LangMap->end(),
DoEmitPopulateLanguageMap(O));
}
// Look for hook invocations in 'cmd_line'.
if (!D.CmdLine)
continue;
- if (dynamic_cast<const StringInit*>(D.CmdLine))
+ if (dynamic_cast<StringInit*>(D.CmdLine))
// This is a string.
ExtractHookNames(HookNames, OptDescs).operator()(D.CmdLine);
else
static const std::string getOptionName(const Record &R) {
// Use the record name unless EnumName is defined.
- if (dynamic_cast<const UnsetInit*>(R.getValueInit("EnumName")))
+ if (dynamic_cast<UnsetInit*>(R.getValueInit("EnumName")))
return R.getName();
return R.getValueAsString("EnumName");
// The containing option group (if any).
OS << ", ";
- if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Group")))
+ if (const DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group")))
OS << getOptionName(*DI->getDef());
else
OS << "INVALID";
OS << ", INVALID, 0, 0";
// The option help text.
- if (!dynamic_cast<const UnsetInit*>(R.getValueInit("HelpText"))) {
+ if (!dynamic_cast<UnsetInit*>(R.getValueInit("HelpText"))) {
OS << ",\n";
OS << " ";
write_cstring(OS, R.getValueAsString("HelpText"));
// The containing option group (if any).
OS << ", ";
- if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Group")))
+ if (const DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Group")))
OS << getOptionName(*DI->getDef());
else
OS << "INVALID";
// The option alias (if any).
OS << ", ";
- if (const DefInit *DI = dynamic_cast<const DefInit*>(R.getValueInit("Alias")))
+ if (const DefInit *DI = dynamic_cast<DefInit*>(R.getValueInit("Alias")))
OS << getOptionName(*DI->getDef());
else
OS << "INVALID";
for (unsigned i = 0, e = LI->size(); i != e; ++i) {
if (i)
OS << " | ";
- OS << dynamic_cast<const DefInit*>(LI->getElement(i))->getDef()->getName();
+ OS << dynamic_cast<DefInit*>(LI->getElement(i))->getDef()->getName();
}
}
OS << ", " << R.getValueAsInt("NumArgs");
// The option help text.
- if (!dynamic_cast<const UnsetInit*>(R.getValueInit("HelpText"))) {
+ if (!dynamic_cast<UnsetInit*>(R.getValueInit("HelpText"))) {
OS << ",\n";
OS << " ";
write_cstring(OS, R.getValueAsString("HelpText"));
// The option meta-variable name.
OS << ", ";
- if (!dynamic_cast<const UnsetInit*>(R.getValueInit("MetaVarName")))
+ if (!dynamic_cast<UnsetInit*>(R.getValueInit("MetaVarName")))
write_cstring(OS, R.getValueAsString("MetaVarName"));
else
OS << "0";
// a single dag, so we can do fancier things.
unsigned PseudoLoweringEmitter::
-addDagOperandMapping(Record *Rec, const DagInit *Dag, CodeGenInstruction &Insn,
+addDagOperandMapping(Record *Rec, DagInit *Dag, CodeGenInstruction &Insn,
IndexedMap<OpData> &OperandMap, unsigned BaseIdx) {
unsigned OpsAdded = 0;
for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) {
- if (const DefInit *DI = dynamic_cast<const DefInit*>(Dag->getArg(i))) {
+ if (DefInit *DI = dynamic_cast<DefInit*>(Dag->getArg(i))) {
// Physical register reference. Explicit check for the special case
// "zero_reg" definition.
if (DI->getDef()->isSubClassOf("Register") ||
for (unsigned I = 0, E = Insn.Operands[i].MINumOperands; I != E; ++I)
OperandMap[BaseIdx + i + I].Kind = OpData::Operand;
OpsAdded += Insn.Operands[i].MINumOperands;
- } else if (const IntInit *II =
- dynamic_cast<const IntInit*>(Dag->getArg(i))) {
+ } else if (IntInit *II = dynamic_cast<IntInit*>(Dag->getArg(i))) {
OperandMap[BaseIdx + i].Kind = OpData::Imm;
OperandMap[BaseIdx + i].Data.Imm = II->getValue();
++OpsAdded;
- } else if (const DagInit *SubDag =
- dynamic_cast<const DagInit*>(Dag->getArg(i))) {
+ } else if (DagInit *SubDag = dynamic_cast<DagInit*>(Dag->getArg(i))) {
// Just add the operands recursively. This is almost certainly
// a constant value for a complex operand (> 1 MI operand).
unsigned NewOps =
// Validate that the result pattern has the corrent number and types
// of arguments for the instruction it references.
- const DagInit *Dag = Rec->getValueAsDag("ResultInst");
+ DagInit *Dag = Rec->getValueAsDag("ResultInst");
assert(Dag && "Missing result instruction in pseudo expansion!");
DEBUG(dbgs() << " Result: " << *Dag << "\n");
- const DefInit *OpDef = dynamic_cast<const DefInit*>(Dag->getOperator());
+ DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator());
if (!OpDef)
throw TGError(Rec->getLoc(), Rec->getName() +
" has unexpected operator type!");
SmallVector<PseudoExpansion, 64> Expansions;
- unsigned addDagOperandMapping(Record *Rec, const DagInit *Dag,
+ unsigned addDagOperandMapping(Record *Rec, DagInit *Dag,
CodeGenInstruction &Insn,
IndexedMap<OpData> &OperandMap,
unsigned BaseIdx);
#include "Error.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Format.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringExtras.h"
using namespace llvm;
void RecTy::dump() const { print(errs()); }
-const Init *BitRecTy::convertValue(const BitsInit *BI) {
+Init *BitRecTy::convertValue(BitsInit *BI) {
if (BI->getNumBits() != 1) return 0; // Only accept if just one bit!
return BI->getBit(0);
}
return RHS->getNumBits() == 1;
}
-const Init *BitRecTy::convertValue(const IntInit *II) {
+Init *BitRecTy::convertValue(IntInit *II) {
int64_t Val = II->getValue();
if (Val != 0 && Val != 1) return 0; // Only accept 0 or 1 for a bit!
- return BitInit::get(Val != 0);
+ return new BitInit(Val != 0);
}
-const Init *BitRecTy::convertValue(const TypedInit *VI) {
+Init *BitRecTy::convertValue(TypedInit *VI) {
if (dynamic_cast<BitRecTy*>(VI->getType()))
return VI; // Accept variable if it is already of bit type!
return 0;
return "bits<" + utostr(Size) + ">";
}
-const Init *BitsRecTy::convertValue(const UnsetInit *UI) {
- SmallVector<const Init *, 16> Bits(Size);
+Init *BitsRecTy::convertValue(UnsetInit *UI) {
+ BitsInit *Ret = new BitsInit(Size);
for (unsigned i = 0; i != Size; ++i)
- Bits[i] = UnsetInit::get();
-
- return BitsInit::get(Bits.begin(), Bits.end());
+ Ret->setBit(i, new UnsetInit());
+ return Ret;
}
-const Init *BitsRecTy::convertValue(const BitInit *UI) {
+Init *BitsRecTy::convertValue(BitInit *UI) {
if (Size != 1) return 0; // Can only convert single bit.
-
- const Init *Bits[1] = { UI };
-
- return BitsInit::get(Bits, array_endof(Bits));
+ BitsInit *Ret = new BitsInit(1);
+ Ret->setBit(0, UI);
+ return Ret;
}
/// canFitInBitfield - Return true if the number of bits is large enough to hold
(Value >> NumBits == 0) || (Value >> (NumBits-1) == -1);
}
-/// convertValue from Int initializer to bits type: Split the integer
-/// up into the appropriate bits.
+/// convertValue from Int initializer to bits type: Split the integer up into the
+/// appropriate bits.
///
-const Init *BitsRecTy::convertValue(const IntInit *II) {
+Init *BitsRecTy::convertValue(IntInit *II) {
int64_t Value = II->getValue();
// Make sure this bitfield is large enough to hold the integer value.
if (!canFitInBitfield(Value, Size))
return 0;
- SmallVector<const Init *, 16> Bits(Size);
-
+ BitsInit *Ret = new BitsInit(Size);
for (unsigned i = 0; i != Size; ++i)
- Bits[i] = BitInit::get(Value & (1LL << i));
+ Ret->setBit(i, new BitInit(Value & (1LL << i)));
- return BitsInit::get(Bits.begin(), Bits.end());
+ return Ret;
}
-const Init *BitsRecTy::convertValue(const BitsInit *BI) {
+Init *BitsRecTy::convertValue(BitsInit *BI) {
// If the number of bits is right, return it. Otherwise we need to expand or
// truncate.
if (BI->getNumBits() == Size) return BI;
return 0;
}
-const Init *BitsRecTy::convertValue(const TypedInit *VI) {
+Init *BitsRecTy::convertValue(TypedInit *VI) {
if (BitsRecTy *BRT = dynamic_cast<BitsRecTy*>(VI->getType()))
if (BRT->Size == Size) {
- SmallVector<const Init *, 16> Bits(Size);
-
+ BitsInit *Ret = new BitsInit(Size);
for (unsigned i = 0; i != Size; ++i)
- Bits[i] = VarBitInit::get(VI, i);
- return BitsInit::get(Bits.begin(), Bits.end());
+ Ret->setBit(i, new VarBitInit(VI, i));
+ return Ret;
}
if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType())) {
- const Init *Bits[1] = { VI };
-
- return BitsInit::get(Bits, array_endof(Bits));
+ BitsInit *Ret = new BitsInit(1);
+ Ret->setBit(0, VI);
+ return Ret;
}
- if (const TernOpInit *Tern = dynamic_cast<const TernOpInit*>(VI)) {
+ if (TernOpInit *Tern = dynamic_cast<TernOpInit*>(VI)) {
if (Tern->getOpcode() == TernOpInit::IF) {
- const Init *LHS = Tern->getLHS();
- const Init *MHS = Tern->getMHS();
- const Init *RHS = Tern->getRHS();
+ Init *LHS = Tern->getLHS();
+ Init *MHS = Tern->getMHS();
+ Init *RHS = Tern->getRHS();
- const IntInit *MHSi = dynamic_cast<const IntInit*>(MHS);
- const IntInit *RHSi = dynamic_cast<const IntInit*>(RHS);
+ IntInit *MHSi = dynamic_cast<IntInit*>(MHS);
+ IntInit *RHSi = dynamic_cast<IntInit*>(RHS);
if (MHSi && RHSi) {
int64_t MHSVal = MHSi->getValue();
int64_t RHSVal = RHSi->getValue();
if (canFitInBitfield(MHSVal, Size) && canFitInBitfield(RHSVal, Size)) {
- SmallVector<const Init *, 16> NewBits(Size);
+ BitsInit *Ret = new BitsInit(Size);
for (unsigned i = 0; i != Size; ++i)
- NewBits[i] =
- TernOpInit::get(TernOpInit::IF, LHS,
- IntInit::get((MHSVal & (1LL << i)) ? 1 : 0),
- IntInit::get((RHSVal & (1LL << i)) ? 1 : 0),
- VI->getType());
-
- return BitsInit::get(NewBits.begin(), NewBits.end());
+ Ret->setBit(i, new TernOpInit(TernOpInit::IF, LHS,
+ new IntInit((MHSVal & (1LL << i)) ? 1 : 0),
+ new IntInit((RHSVal & (1LL << i)) ? 1 : 0),
+ VI->getType()));
+
+ return Ret;
}
} else {
- const BitsInit *MHSbs = dynamic_cast<const BitsInit*>(MHS);
- const BitsInit *RHSbs = dynamic_cast<const BitsInit*>(RHS);
+ BitsInit *MHSbs = dynamic_cast<BitsInit*>(MHS);
+ BitsInit *RHSbs = dynamic_cast<BitsInit*>(RHS);
if (MHSbs && RHSbs) {
- SmallVector<const Init *, 16> NewBits(Size);
+ BitsInit *Ret = new BitsInit(Size);
for (unsigned i = 0; i != Size; ++i)
- NewBits[i] = TernOpInit::get(TernOpInit::IF, LHS,
- MHSbs->getBit(i),
- RHSbs->getBit(i),
- VI->getType());
+ Ret->setBit(i, new TernOpInit(TernOpInit::IF, LHS,
+ MHSbs->getBit(i),
+ RHSbs->getBit(i),
+ VI->getType()));
- return BitsInit::get(NewBits.begin(), NewBits.end());
+ return Ret;
}
}
}
return 0;
}
-const Init *IntRecTy::convertValue(const BitInit *BI) {
- return IntInit::get(BI->getValue());
+Init *IntRecTy::convertValue(BitInit *BI) {
+ return new IntInit(BI->getValue());
}
-const Init *IntRecTy::convertValue(const BitsInit *BI) {
+Init *IntRecTy::convertValue(BitsInit *BI) {
int64_t Result = 0;
for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
- if (const BitInit *Bit = dynamic_cast<const BitInit*>(BI->getBit(i))) {
+ if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) {
Result |= Bit->getValue() << i;
} else {
return 0;
}
- return IntInit::get(Result);
+ return new IntInit(Result);
}
-const Init *IntRecTy::convertValue(const TypedInit *TI) {
+Init *IntRecTy::convertValue(TypedInit *TI) {
if (TI->getType()->typeIsConvertibleTo(this))
return TI; // Accept variable if already of the right type!
return 0;
}
-const Init *StringRecTy::convertValue(const UnOpInit *BO) {
+Init *StringRecTy::convertValue(UnOpInit *BO) {
if (BO->getOpcode() == UnOpInit::CAST) {
- const Init *L = BO->getOperand()->convertInitializerTo(this);
+ Init *L = BO->getOperand()->convertInitializerTo(this);
if (L == 0) return 0;
if (L != BO->getOperand())
- return UnOpInit::get(UnOpInit::CAST, L, new StringRecTy);
+ return new UnOpInit(UnOpInit::CAST, L, new StringRecTy);
return BO;
}
- return convertValue((const TypedInit*)BO);
+ return convertValue((TypedInit*)BO);
}
-const Init *StringRecTy::convertValue(const BinOpInit *BO) {
+Init *StringRecTy::convertValue(BinOpInit *BO) {
if (BO->getOpcode() == BinOpInit::STRCONCAT) {
- const Init *L = BO->getLHS()->convertInitializerTo(this);
- const Init *R = BO->getRHS()->convertInitializerTo(this);
+ Init *L = BO->getLHS()->convertInitializerTo(this);
+ Init *R = BO->getRHS()->convertInitializerTo(this);
if (L == 0 || R == 0) return 0;
if (L != BO->getLHS() || R != BO->getRHS())
- return BinOpInit::get(BinOpInit::STRCONCAT, L, R, new StringRecTy);
+ return new BinOpInit(BinOpInit::STRCONCAT, L, R, new StringRecTy);
return BO;
}
- return convertValue((const TypedInit*)BO);
+ return convertValue((TypedInit*)BO);
}
-const Init *StringRecTy::convertValue(const TypedInit *TI) {
+Init *StringRecTy::convertValue(TypedInit *TI) {
if (dynamic_cast<StringRecTy*>(TI->getType()))
return TI; // Accept variable if already of the right type!
return 0;
return "list<" + Ty->getAsString() + ">";
}
-const Init *ListRecTy::convertValue(const ListInit *LI) {
- std::vector<const Init*> Elements;
+Init *ListRecTy::convertValue(ListInit *LI) {
+ std::vector<Init*> Elements;
// Verify that all of the elements of the list are subclasses of the
// appropriate class!
for (unsigned i = 0, e = LI->getSize(); i != e; ++i)
- if (const Init *CI = LI->getElement(i)->convertInitializerTo(Ty))
+ if (Init *CI = LI->getElement(i)->convertInitializerTo(Ty))
Elements.push_back(CI);
else
return 0;
return 0;
}
- return ListInit::get(Elements, new ListRecTy(Ty));
+ return new ListInit(Elements, new ListRecTy(Ty));
}
-const Init *ListRecTy::convertValue(const TypedInit *TI) {
+Init *ListRecTy::convertValue(TypedInit *TI) {
// Ensure that TI is compatible with our class.
if (ListRecTy *LRT = dynamic_cast<ListRecTy*>(TI->getType()))
if (LRT->getElementType()->typeIsConvertibleTo(getElementType()))
return 0;
}
-const Init *CodeRecTy::convertValue(const TypedInit *TI) {
+Init *CodeRecTy::convertValue(TypedInit *TI) {
if (TI->getType()->typeIsConvertibleTo(this))
return TI;
return 0;
}
-const Init *DagRecTy::convertValue(const TypedInit *TI) {
+Init *DagRecTy::convertValue(TypedInit *TI) {
if (TI->getType()->typeIsConvertibleTo(this))
return TI;
return 0;
}
-const Init *DagRecTy::convertValue(const UnOpInit *BO) {
+Init *DagRecTy::convertValue(UnOpInit *BO) {
if (BO->getOpcode() == UnOpInit::CAST) {
- const Init *L = BO->getOperand()->convertInitializerTo(this);
+ Init *L = BO->getOperand()->convertInitializerTo(this);
if (L == 0) return 0;
if (L != BO->getOperand())
- return UnOpInit::get(UnOpInit::CAST, L, new DagRecTy);
+ return new UnOpInit(UnOpInit::CAST, L, new DagRecTy);
return BO;
}
return 0;
}
-const Init *DagRecTy::convertValue(const BinOpInit *BO) {
+Init *DagRecTy::convertValue(BinOpInit *BO) {
if (BO->getOpcode() == BinOpInit::CONCAT) {
- const Init *L = BO->getLHS()->convertInitializerTo(this);
- const Init *R = BO->getRHS()->convertInitializerTo(this);
+ Init *L = BO->getLHS()->convertInitializerTo(this);
+ Init *R = BO->getRHS()->convertInitializerTo(this);
if (L == 0 || R == 0) return 0;
if (L != BO->getLHS() || R != BO->getRHS())
- return BinOpInit::get(BinOpInit::CONCAT, L, R, new DagRecTy);
+ return new BinOpInit(BinOpInit::CONCAT, L, R, new DagRecTy);
return BO;
}
return 0;
return Rec->getName();
}
-const Init *RecordRecTy::convertValue(const DefInit *DI) {
+Init *RecordRecTy::convertValue(DefInit *DI) {
// Ensure that DI is a subclass of Rec.
if (!DI->getDef()->isSubClassOf(Rec))
return 0;
return DI;
}
-const Init *RecordRecTy::convertValue(const TypedInit *TI) {
+Init *RecordRecTy::convertValue(TypedInit *TI) {
// Ensure that TI is compatible with Rec.
if (RecordRecTy *RRT = dynamic_cast<RecordRecTy*>(TI->getType()))
if (RRT->getRecord()->isSubClassOf(getRecord()) ||
// Initializer implementations
//===----------------------------------------------------------------------===//
-FoldingSet<Init> Init::UniqueInits;
-BumpPtrAllocator Init::InitAllocator;
-
void Init::dump() const { return print(errs()); }
-const UnsetInit *UnsetInit::get() {
- FoldingSetNodeID ID;
- ID.AddInteger(initUnset);
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const UnsetInit *>(I);
-
- UnsetInit *I = InitAllocator.Allocate<UnsetInit>();
- new (I) UnsetInit(ID);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
-
-const BitInit *BitInit::get(bool V) {
- FoldingSetNodeID ID;
- ID.AddInteger(initBit);
- ID.AddBoolean(V);
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const BitInit *>(I);
-
- BitInit *I = InitAllocator.Allocate<BitInit>();
- new (I) BitInit(ID, V);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
-
-const Init *
-BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
- SmallVector<const Init *, 16> NewBits(Bits.size());
-
+Init *BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+ BitsInit *BI = new BitsInit(Bits.size());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= getNumBits()) {
+ delete BI;
return 0;
}
- NewBits[i] = getBit(Bits[i]);
+ BI->setBit(i, getBit(Bits[i]));
}
-
- return BitsInit::get(NewBits.begin(), NewBits.end());
+ return BI;
}
std::string BitsInit::getAsString() const {
std::string Result = "{ ";
for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
if (i) Result += ", ";
- if (const Init *Bit = getBit(e-i-1))
+ if (Init *Bit = getBit(e-i-1))
Result += Bit->getAsString();
else
Result += "*";
// resolveReferences - If there are any field references that refer to fields
// that have been filled in, we can propagate the values now.
//
-const Init *BitsInit::resolveReferences(Record &R,
- const RecordVal *RV) const {
+Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) {
bool Changed = false;
+ BitsInit *New = new BitsInit(getNumBits());
- SmallVector<const Init *, 16> Bits(getNumBits());
-
- for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
- const Init *B;
- const Init *CurBit = getBit(i);
+ for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
+ Init *B;
+ Init *CurBit = getBit(i);
do {
B = CurBit;
CurBit = CurBit->resolveReferences(R, RV);
Changed |= B != CurBit;
} while (B != CurBit);
- Bits[i] = CurBit;
+ New->setBit(i, CurBit);
}
if (Changed)
- return BitsInit::get(Bits.begin(), Bits.end());
-
+ return New;
+ delete New;
return this;
}
-const IntInit *IntInit::get(int64_t V) {
- FoldingSetNodeID ID;
- ID.AddInteger(initInt);
- ID.AddInteger(V);
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const IntInit *>(I);
-
- IntInit *I = InitAllocator.Allocate<IntInit>();
- new (I) IntInit(ID, V);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
-
std::string IntInit::getAsString() const {
return itostr(Value);
}
-const Init *
-IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
- SmallVector<const Init *, 16> NewBits(Bits.size());
+Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
+ BitsInit *BI = new BitsInit(Bits.size());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
- if (Bits[i] >= 64)
+ if (Bits[i] >= 64) {
+ delete BI;
return 0;
-
- NewBits[i] = BitInit::get(Value & (INT64_C(1) << Bits[i]));
- }
-
- return BitsInit::get(NewBits.begin(), NewBits.end());
-}
-
-const StringInit *StringInit::get(const std::string &V) {
- FoldingSetNodeID ID;
- ID.AddInteger(initString);
- ID.AddString(V);
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const StringInit *>(I);
-
- StringInit *I = InitAllocator.Allocate<StringInit>();
- new (I) StringInit(ID, V);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
-
-const CodeInit *CodeInit::get(const std::string &V) {
- FoldingSetNodeID ID;
- ID.AddInteger(initCode);
- ID.AddString(V);
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const CodeInit *>(I);
-
- CodeInit *I = InitAllocator.Allocate<CodeInit>();
- new (I) CodeInit(ID, V);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
-
-const ListInit *ListInit::get(std::vector<const Init *> &Vs, RecTy *EltTy) {
- FoldingSetNodeID ID;
- ID.AddInteger(initList);
- ID.AddString(EltTy->getAsString());
-
- for (std::vector<const Init *>::iterator i = Vs.begin(), iend = Vs.end();
- i != iend;
- ++i) {
- ID.AddPointer(*i);
+ }
+ BI->setBit(i, new BitInit(Value & (INT64_C(1) << Bits[i])));
}
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const ListInit *>(I);
-
- ListInit *I = InitAllocator.Allocate<ListInit>();
- new (I) ListInit(ID, Vs, EltTy);
- UniqueInits.InsertNode(I, IP);
- return I;
+ return BI;
}
-const Init *
-ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const {
- std::vector<const Init*> Vals;
+Init *ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
+ std::vector<Init*> Vals;
for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
if (Elements[i] >= getSize())
return 0;
Vals.push_back(getElement(Elements[i]));
}
- return ListInit::get(Vals, getType());
+ return new ListInit(Vals, getType());
}
Record *ListInit::getElementAsRecord(unsigned i) const {
assert(i < Values.size() && "List element index out of range!");
- const DefInit *DI = dynamic_cast<const DefInit*>(Values[i]);
+ DefInit *DI = dynamic_cast<DefInit*>(Values[i]);
if (DI == 0) throw "Expected record in list!";
return DI->getDef();
}
-const Init *ListInit::resolveReferences(Record &R,
- const RecordVal *RV) const {
- std::vector<const Init*> Resolved;
+Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) {
+ std::vector<Init*> Resolved;
Resolved.reserve(getSize());
bool Changed = false;
for (unsigned i = 0, e = getSize(); i != e; ++i) {
- const Init *E;
- const Init *CurElt = getElement(i);
+ Init *E;
+ Init *CurElt = getElement(i);
do {
E = CurElt;
}
if (Changed)
- return ListInit::get(Resolved, getType());
-
+ return new ListInit(Resolved, getType());
return this;
}
-const Init *ListInit::resolveListElementReference(Record &R,
- const RecordVal *IRV,
- unsigned Elt) const {
+Init *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV,
+ unsigned Elt) {
if (Elt >= getSize())
return 0; // Out of range reference.
-
- const Init *E = getElement(Elt);
-
+ Init *E = getElement(Elt);
// If the element is set to some value, or if we are resolving a reference
// to a specific variable and that variable is explicitly unset, then
// replace the VarListElementInit with it.
- if (IRV || !dynamic_cast<const UnsetInit*>(E))
+ if (IRV || !dynamic_cast<UnsetInit*>(E))
return E;
-
return 0;
}
return Result + "]";
}
-const Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV,
- unsigned Bit) const {
- const Init *Folded = Fold(&R, 0);
+Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV,
+ unsigned Bit) {
+ Init *Folded = Fold(&R, 0);
if (Folded != this) {
- const TypedInit *Typed = dynamic_cast<const TypedInit *>(Folded);
+ TypedInit *Typed = dynamic_cast<TypedInit *>(Folded);
if (Typed) {
return Typed->resolveBitReference(R, IRV, Bit);
}
return 0;
}
-const Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV,
- unsigned Elt) const {
- const Init *Folded = Fold(&R, 0);
+Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV,
+ unsigned Elt) {
+ Init *Folded = Fold(&R, 0);
if (Folded != this) {
- const TypedInit *Typed = dynamic_cast<const TypedInit *>(Folded);
+ TypedInit *Typed = dynamic_cast<TypedInit *>(Folded);
if (Typed) {
return Typed->resolveListElementReference(R, IRV, Elt);
}
return 0;
}
-const UnOpInit *UnOpInit::get(UnaryOp opc, const Init *lhs, RecTy *Type) {
- FoldingSetNodeID ID;
- ID.AddInteger(initUnOp);
- ID.AddInteger(opc);
- ID.AddString(Type->getAsString());
- ID.AddPointer(lhs);
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const UnOpInit *>(I);
-
- UnOpInit *I = InitAllocator.Allocate<UnOpInit>();
- new (I) UnOpInit(ID, opc, lhs, Type);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
-
-const Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
+Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
switch (getOpcode()) {
default: assert(0 && "Unknown unop");
case CAST: {
if (getType()->getAsString() == "string") {
- const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+ StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
if (LHSs) {
return LHSs;
}
- const DefInit *LHSd = dynamic_cast<const DefInit*>(LHS);
+ DefInit *LHSd = dynamic_cast<DefInit*>(LHS);
if (LHSd) {
- return StringInit::get(LHSd->getDef()->getName());
+ return new StringInit(LHSd->getDef()->getName());
}
} else {
- const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+ StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
if (LHSs) {
std::string Name = LHSs->getValue();
if (const RecordVal *RV = CurRec->getValue(Name)) {
if (RV->getType() != getType())
throw "type mismatch in cast";
- return VarInit::get(Name, RV->getType());
+ return new VarInit(Name, RV->getType());
}
std::string TemplateArgName = CurRec->getName()+":"+Name;
if (RV->getType() != getType())
throw "type mismatch in cast";
- return VarInit::get(TemplateArgName, RV->getType());
+ return new VarInit(TemplateArgName, RV->getType());
}
}
if (RV->getType() != getType())
throw "type mismatch in cast";
- return VarInit::get(MCName, RV->getType());
+ return new VarInit(MCName, RV->getType());
}
}
if (Record *D = (CurRec->getRecords()).getDef(Name))
- return DefInit::get(D);
+ return new DefInit(D);
throw TGError(CurRec->getLoc(), "Undefined reference:'" + Name + "'\n");
}
break;
}
case HEAD: {
- const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
+ ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
if (LHSl) {
if (LHSl->getSize() == 0) {
assert(0 && "Empty list in car");
break;
}
case TAIL: {
- const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
+ ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
if (LHSl) {
if (LHSl->getSize() == 0) {
assert(0 && "Empty list in cdr");
return 0;
}
- const ListInit *Result = ListInit::get(LHSl->begin()+1, LHSl->end(),
- LHSl->getType());
+ ListInit *Result = new ListInit(LHSl->begin()+1, LHSl->end(),
+ LHSl->getType());
return Result;
}
break;
}
case EMPTY: {
- const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
+ ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
if (LHSl) {
if (LHSl->getSize() == 0) {
- return IntInit::get(1);
+ return new IntInit(1);
} else {
- return IntInit::get(0);
+ return new IntInit(0);
}
}
- const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+ StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
if (LHSs) {
if (LHSs->getValue().empty()) {
- return IntInit::get(1);
+ return new IntInit(1);
} else {
- return IntInit::get(0);
+ return new IntInit(0);
}
}
return this;
}
-const Init *UnOpInit::resolveReferences(Record &R,
- const RecordVal *RV) const {
- const Init *lhs = LHS->resolveReferences(R, RV);
+Init *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) {
+ Init *lhs = LHS->resolveReferences(R, RV);
if (LHS != lhs)
- return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, 0);
+ return (new UnOpInit(getOpcode(), lhs, getType()))->Fold(&R, 0);
return Fold(&R, 0);
}
return Result + "(" + LHS->getAsString() + ")";
}
-const BinOpInit *BinOpInit::get(BinaryOp opc, const Init *lhs,
- const Init *rhs, RecTy *Type) {
- FoldingSetNodeID ID;
- ID.AddInteger(initBinOp);
- ID.AddInteger(opc);
- ID.AddString(Type->getAsString());
- ID.AddPointer(lhs);
- ID.AddPointer(rhs);
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const BinOpInit *>(I);
-
- BinOpInit *I = InitAllocator.Allocate<BinOpInit>();
- new (I) BinOpInit(ID, opc, lhs, rhs, Type);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
-
-const Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
+Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
switch (getOpcode()) {
default: assert(0 && "Unknown binop");
case CONCAT: {
- const DagInit *LHSs = dynamic_cast<const DagInit*>(LHS);
- const DagInit *RHSs = dynamic_cast<const DagInit*>(RHS);
+ DagInit *LHSs = dynamic_cast<DagInit*>(LHS);
+ DagInit *RHSs = dynamic_cast<DagInit*>(RHS);
if (LHSs && RHSs) {
- const DefInit *LOp = dynamic_cast<const DefInit*>(LHSs->getOperator());
- const DefInit *ROp = dynamic_cast<const DefInit*>(RHSs->getOperator());
+ DefInit *LOp = dynamic_cast<DefInit*>(LHSs->getOperator());
+ DefInit *ROp = dynamic_cast<DefInit*>(RHSs->getOperator());
if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef())
throw "Concated Dag operators do not match!";
- std::vector<const Init*> Args;
+ std::vector<Init*> Args;
std::vector<std::string> ArgNames;
for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) {
Args.push_back(LHSs->getArg(i));
Args.push_back(RHSs->getArg(i));
ArgNames.push_back(RHSs->getArgName(i));
}
- return DagInit::get(LHSs->getOperator(), "", Args, ArgNames);
+ return new DagInit(LHSs->getOperator(), "", Args, ArgNames);
}
break;
}
case STRCONCAT: {
- const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
- const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS);
+ StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+ StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
if (LHSs && RHSs)
- return StringInit::get(LHSs->getValue() + RHSs->getValue());
+ return new StringInit(LHSs->getValue() + RHSs->getValue());
break;
}
case EQ: {
// try to fold eq comparison for 'bit' and 'int', otherwise fallback
// to string objects.
- const IntInit* L =
- dynamic_cast<const IntInit*>(LHS->convertInitializerTo(new IntRecTy()));
- const IntInit* R =
- dynamic_cast<const IntInit*>(RHS->convertInitializerTo(new IntRecTy()));
+ IntInit* L =
+ dynamic_cast<IntInit*>(LHS->convertInitializerTo(new IntRecTy()));
+ IntInit* R =
+ dynamic_cast<IntInit*>(RHS->convertInitializerTo(new IntRecTy()));
if (L && R)
- return IntInit::get(L->getValue() == R->getValue());
+ return new IntInit(L->getValue() == R->getValue());
- const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
- const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS);
+ StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+ StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
// Make sure we've resolved
if (LHSs && RHSs)
- return IntInit::get(LHSs->getValue() == RHSs->getValue());
+ return new IntInit(LHSs->getValue() == RHSs->getValue());
break;
}
case SHL:
case SRA:
case SRL: {
- const IntInit *LHSi = dynamic_cast<const IntInit*>(LHS);
- const IntInit *RHSi = dynamic_cast<const IntInit*>(RHS);
+ IntInit *LHSi = dynamic_cast<IntInit*>(LHS);
+ IntInit *RHSi = dynamic_cast<IntInit*>(RHS);
if (LHSi && RHSi) {
int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue();
int64_t Result;
case SRA: Result = LHSv >> RHSv; break;
case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break;
}
- return IntInit::get(Result);
+ return new IntInit(Result);
}
break;
}
return this;
}
-const Init *BinOpInit::resolveReferences(Record &R,
- const RecordVal *RV) const {
- const Init *lhs = LHS->resolveReferences(R, RV);
- const Init *rhs = RHS->resolveReferences(R, RV);
+Init *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) {
+ Init *lhs = LHS->resolveReferences(R, RV);
+ Init *rhs = RHS->resolveReferences(R, RV);
if (LHS != lhs || RHS != rhs)
- return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0);
+ return (new BinOpInit(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0);
return Fold(&R, 0);
}
return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
}
-const TernOpInit *TernOpInit::get(TernaryOp opc, const Init *lhs,
- const Init *mhs, const Init *rhs,
- RecTy *Type) {
- FoldingSetNodeID ID;
- ID.AddInteger(initTernOp);
- ID.AddInteger(opc);
- ID.AddString(Type->getAsString());
- ID.AddPointer(lhs);
- ID.AddPointer(mhs);
- ID.AddPointer(rhs);
+static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
+ Record *CurRec, MultiClass *CurMultiClass);
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const TernOpInit *>(I);
-
- TernOpInit *I = InitAllocator.Allocate<TernOpInit>();
- new (I) TernOpInit(ID, opc, lhs, mhs, rhs, Type);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
+static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
+ RecTy *Type, Record *CurRec,
+ MultiClass *CurMultiClass) {
+ std::vector<Init *> NewOperands;
-static const Init *ForeachHelper(const Init *LHS, const Init *MHS,
- const Init *RHS, RecTy *Type,
- Record *CurRec, MultiClass *CurMultiClass);
-
-static const Init *EvaluateOperation(const OpInit *RHSo, const Init *LHS,
- const Init *Arg, RecTy *Type,
- Record *CurRec,
- MultiClass *CurMultiClass) {
- std::vector<const Init *> NewOperands;
-
- const TypedInit *TArg = dynamic_cast<const TypedInit*>(Arg);
+ TypedInit *TArg = dynamic_cast<TypedInit*>(Arg);
// If this is a dag, recurse
if (TArg && TArg->getType()->getAsString() == "dag") {
- const Init *Result = ForeachHelper(LHS, Arg, RHSo, Type,
- CurRec, CurMultiClass);
+ Init *Result = ForeachHelper(LHS, Arg, RHSo, Type,
+ CurRec, CurMultiClass);
if (Result != 0) {
return Result;
} else {
}
}
- bool change = false;
for (int i = 0; i < RHSo->getNumOperands(); ++i) {
- const OpInit *RHSoo = dynamic_cast<const OpInit*>(RHSo->getOperand(i));
+ OpInit *RHSoo = dynamic_cast<OpInit*>(RHSo->getOperand(i));
if (RHSoo) {
- const Init *Result = EvaluateOperation(RHSoo, LHS, Arg,
- Type, CurRec, CurMultiClass);
+ Init *Result = EvaluateOperation(RHSoo, LHS, Arg,
+ Type, CurRec, CurMultiClass);
if (Result != 0) {
- change = true;
NewOperands.push_back(Result);
} else {
NewOperands.push_back(Arg);
}
} else if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) {
- change = true;
NewOperands.push_back(Arg);
} else {
NewOperands.push_back(RHSo->getOperand(i));
}
// Now run the operator and use its result as the new leaf
- const OpInit *NewOp = RHSo->clone(NewOperands);
- const Init *NewVal = NewOp->Fold(CurRec, CurMultiClass);
-
- if (change) {
+ OpInit *NewOp = RHSo->clone(NewOperands);
+ Init *NewVal = NewOp->Fold(CurRec, CurMultiClass);
+ if (NewVal != NewOp) {
+ delete NewOp;
return NewVal;
}
return 0;
}
-static const Init *ForeachHelper(const Init *LHS, const Init *MHS,
- const Init *RHS, RecTy *Type,
- Record *CurRec, MultiClass *CurMultiClass) {
- const DagInit *MHSd = dynamic_cast<const DagInit*>(MHS);
- const ListInit *MHSl = dynamic_cast<const ListInit*>(MHS);
+static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
+ Record *CurRec, MultiClass *CurMultiClass) {
+ DagInit *MHSd = dynamic_cast<DagInit*>(MHS);
+ ListInit *MHSl = dynamic_cast<ListInit*>(MHS);
DagRecTy *DagType = dynamic_cast<DagRecTy*>(Type);
ListRecTy *ListType = dynamic_cast<ListRecTy*>(Type);
- const OpInit *RHSo = dynamic_cast<const OpInit*>(RHS);
+ OpInit *RHSo = dynamic_cast<OpInit*>(RHS);
if (!RHSo) {
throw TGError(CurRec->getLoc(), "!foreach requires an operator\n");
}
- const TypedInit *LHSt = dynamic_cast<const TypedInit*>(LHS);
+ TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS);
if (!LHSt) {
throw TGError(CurRec->getLoc(), "!foreach requires typed variable\n");
if ((MHSd && DagType) || (MHSl && ListType)) {
if (MHSd) {
- const Init *Val = MHSd->getOperator();
- const Init *Result = EvaluateOperation(RHSo, LHS, Val,
- Type, CurRec, CurMultiClass);
+ Init *Val = MHSd->getOperator();
+ Init *Result = EvaluateOperation(RHSo, LHS, Val,
+ Type, CurRec, CurMultiClass);
if (Result != 0) {
Val = Result;
}
- std::vector<std::pair<const Init *, std::string> > args;
+ std::vector<std::pair<Init *, std::string> > args;
for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) {
- const Init *Arg;
+ Init *Arg;
std::string ArgName;
Arg = MHSd->getArg(i);
ArgName = MHSd->getArgName(i);
// Process args
- const Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type,
- CurRec, CurMultiClass);
+ Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type,
+ CurRec, CurMultiClass);
if (Result != 0) {
Arg = Result;
}
args.push_back(std::make_pair(Arg, ArgName));
}
- return DagInit::get(Val, "", args);
+ return new DagInit(Val, "", args);
}
if (MHSl) {
- std::vector<const Init *> NewOperands;
- std::vector<const Init *> NewList(MHSl->begin(), MHSl->end());
+ std::vector<Init *> NewOperands;
+ std::vector<Init *> NewList(MHSl->begin(), MHSl->end());
- for (std::vector<const Init *>::iterator li = NewList.begin(),
+ for (ListInit::iterator li = NewList.begin(),
liend = NewList.end();
li != liend;
++li) {
- const Init *Item = *li;
+ Init *Item = *li;
NewOperands.clear();
for(int i = 0; i < RHSo->getNumOperands(); ++i) {
// First, replace the foreach variable with the list item
}
// Now run the operator and use its result as the new list item
- const OpInit *NewOp = RHSo->clone(NewOperands);
- const Init *NewItem = NewOp->Fold(CurRec, CurMultiClass);
+ OpInit *NewOp = RHSo->clone(NewOperands);
+ Init *NewItem = NewOp->Fold(CurRec, CurMultiClass);
if (NewItem != NewOp) {
*li = NewItem;
+ delete NewOp;
}
}
- return ListInit::get(NewList, MHSl->getType());
+ return new ListInit(NewList, MHSl->getType());
}
}
return 0;
}
-const Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
+Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
switch (getOpcode()) {
default: assert(0 && "Unknown binop");
case SUBST: {
- const DefInit *LHSd = dynamic_cast<const DefInit*>(LHS);
- const VarInit *LHSv = dynamic_cast<const VarInit*>(LHS);
- const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
+ DefInit *LHSd = dynamic_cast<DefInit*>(LHS);
+ VarInit *LHSv = dynamic_cast<VarInit*>(LHS);
+ StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
- const DefInit *MHSd = dynamic_cast<const DefInit*>(MHS);
- const VarInit *MHSv = dynamic_cast<const VarInit*>(MHS);
- const StringInit *MHSs = dynamic_cast<const StringInit*>(MHS);
+ DefInit *MHSd = dynamic_cast<DefInit*>(MHS);
+ VarInit *MHSv = dynamic_cast<VarInit*>(MHS);
+ StringInit *MHSs = dynamic_cast<StringInit*>(MHS);
- const DefInit *RHSd = dynamic_cast<const DefInit*>(RHS);
- const VarInit *RHSv = dynamic_cast<const VarInit*>(RHS);
- const StringInit *RHSs = dynamic_cast<const StringInit*>(RHS);
+ DefInit *RHSd = dynamic_cast<DefInit*>(RHS);
+ VarInit *RHSv = dynamic_cast<VarInit*>(RHS);
+ StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
if ((LHSd && MHSd && RHSd)
|| (LHSv && MHSv && RHSv)
if (LHSd->getAsString() == RHSd->getAsString()) {
Val = MHSd->getDef();
}
- return DefInit::get(Val);
+ return new DefInit(Val);
}
if (RHSv) {
std::string Val = RHSv->getName();
if (LHSv->getAsString() == RHSv->getAsString()) {
Val = MHSv->getName();
}
- return VarInit::get(Val, getType());
+ return new VarInit(Val, getType());
}
if (RHSs) {
std::string Val = RHSs->getValue();
idx = found + MHSs->getValue().size();
} while (found != std::string::npos);
- return StringInit::get(Val);
+ return new StringInit(Val);
}
}
break;
}
case FOREACH: {
- const Init *Result = ForeachHelper(LHS, MHS, RHS, getType(),
+ Init *Result = ForeachHelper(LHS, MHS, RHS, getType(),
CurRec, CurMultiClass);
if (Result != 0) {
return Result;
}
case IF: {
- const IntInit *LHSi = dynamic_cast<const IntInit*>(LHS);
- if (const Init *I = LHS->convertInitializerTo(new IntRecTy()))
- LHSi = dynamic_cast<const IntInit*>(I);
+ IntInit *LHSi = dynamic_cast<IntInit*>(LHS);
+ if (Init *I = LHS->convertInitializerTo(new IntRecTy()))
+ LHSi = dynamic_cast<IntInit*>(I);
if (LHSi) {
if (LHSi->getValue()) {
return MHS;
return this;
}
-const Init *
-TernOpInit::resolveReferences(Record &R,
- const RecordVal *RV) const {
- const Init *lhs = LHS->resolveReferences(R, RV);
+Init *TernOpInit::resolveReferences(Record &R, const RecordVal *RV) {
+ Init *lhs = LHS->resolveReferences(R, RV);
if (Opc == IF && lhs != LHS) {
- const IntInit *Value = dynamic_cast<const IntInit*>(lhs);
- if (const Init *I = lhs->convertInitializerTo(new IntRecTy()))
- Value = dynamic_cast<const IntInit*>(I);
+ IntInit *Value = dynamic_cast<IntInit*>(lhs);
+ if (Init *I = lhs->convertInitializerTo(new IntRecTy()))
+ Value = dynamic_cast<IntInit*>(I);
if (Value != 0) {
// Short-circuit
if (Value->getValue()) {
- const Init *mhs = MHS->resolveReferences(R, RV);
- return (TernOpInit::get(getOpcode(), lhs, mhs,
- RHS, getType()))->Fold(&R, 0);
+ Init *mhs = MHS->resolveReferences(R, RV);
+ return (new TernOpInit(getOpcode(), lhs, mhs,
+ RHS, getType()))->Fold(&R, 0);
} else {
- const Init *rhs = RHS->resolveReferences(R, RV);
- return (TernOpInit::get(getOpcode(), lhs, MHS,
- rhs, getType()))->Fold(&R, 0);
+ Init *rhs = RHS->resolveReferences(R, RV);
+ return (new TernOpInit(getOpcode(), lhs, MHS,
+ rhs, getType()))->Fold(&R, 0);
}
}
}
- const Init *mhs = MHS->resolveReferences(R, RV);
- const Init *rhs = RHS->resolveReferences(R, RV);
+ Init *mhs = MHS->resolveReferences(R, RV);
+ Init *rhs = RHS->resolveReferences(R, RV);
if (LHS != lhs || MHS != mhs || RHS != rhs)
- return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, getType()))->
- Fold(&R, 0);
+ return (new TernOpInit(getOpcode(), lhs, mhs, rhs, getType()))->Fold(&R, 0);
return Fold(&R, 0);
}
return 0;
}
-const Init *
-TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
+Init *TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
BitsRecTy *T = dynamic_cast<BitsRecTy*>(getType());
if (T == 0) return 0; // Cannot subscript a non-bits variable.
unsigned NumBits = T->getNumBits();
- SmallVector<const Init *, 16> NewBits(Bits.size());
+ BitsInit *BI = new BitsInit(Bits.size());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= NumBits) {
+ delete BI;
return 0;
}
- NewBits[i] = VarBitInit::get(this, Bits[i]);
+ BI->setBit(i, new VarBitInit(this, Bits[i]));
}
- return BitsInit::get(NewBits.begin(), NewBits.end());
+ return BI;
}
-const Init *
-TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const {
+Init *TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
ListRecTy *T = dynamic_cast<ListRecTy*>(getType());
if (T == 0) return 0; // Cannot subscript a non-list variable.
if (Elements.size() == 1)
- return VarListElementInit::get(this, Elements[0]);
+ return new VarListElementInit(this, Elements[0]);
- std::vector<const Init*> ListInits;
+ std::vector<Init*> ListInits;
ListInits.reserve(Elements.size());
for (unsigned i = 0, e = Elements.size(); i != e; ++i)
- ListInits.push_back(VarListElementInit::get(this, Elements[i]));
- return ListInit::get(ListInits, T);
+ ListInits.push_back(new VarListElementInit(this, Elements[i]));
+ return new ListInit(ListInits, T);
}
-const VarInit *VarInit::get(const std::string &VN, RecTy *T) {
- FoldingSetNodeID ID;
- ID.AddInteger(initVar);
- ID.AddString(VN);
- ID.AddString(T->getAsString());
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const VarInit *>(I);
-
- VarInit *I = InitAllocator.Allocate<VarInit>();
- new (I) VarInit(ID, VN, T);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
-
-const Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV,
- unsigned Bit) const {
+Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV,
+ unsigned Bit) {
if (R.isTemplateArg(getName())) return 0;
if (IRV && IRV->getName() != getName()) return 0;
RecordVal *RV = R.getValue(getName());
assert(RV && "Reference to a non-existent variable?");
- assert(dynamic_cast<const BitsInit*>(RV->getValue()));
- const BitsInit *BI = (const BitsInit*)RV->getValue();
+ assert(dynamic_cast<BitsInit*>(RV->getValue()));
+ BitsInit *BI = (BitsInit*)RV->getValue();
assert(Bit < BI->getNumBits() && "Bit reference out of range!");
- const Init *B = BI->getBit(Bit);
+ Init *B = BI->getBit(Bit);
// If the bit is set to some value, or if we are resolving a reference to a
// specific variable and that variable is explicitly unset, then replace the
// VarBitInit with it.
- if (IRV || !dynamic_cast<const UnsetInit*>(B))
+ if (IRV || !dynamic_cast<UnsetInit*>(B))
return B;
return 0;
}
-const Init *VarInit::resolveListElementReference(Record &R,
- const RecordVal *IRV,
- unsigned Elt) const {
+Init *VarInit::resolveListElementReference(Record &R, const RecordVal *IRV,
+ unsigned Elt) {
if (R.isTemplateArg(getName())) return 0;
if (IRV && IRV->getName() != getName()) return 0;
RecordVal *RV = R.getValue(getName());
assert(RV && "Reference to a non-existent variable?");
- const ListInit *LI = dynamic_cast<const ListInit*>(RV->getValue());
+ ListInit *LI = dynamic_cast<ListInit*>(RV->getValue());
if (!LI) {
- const VarInit *VI = dynamic_cast<const VarInit*>(RV->getValue());
+ VarInit *VI = dynamic_cast<VarInit*>(RV->getValue());
assert(VI && "Invalid list element!");
- return VarListElementInit::get(VI, Elt);
+ return new VarListElementInit(VI, Elt);
}
if (Elt >= LI->getSize())
return 0; // Out of range reference.
- const Init *E = LI->getElement(Elt);
+ Init *E = LI->getElement(Elt);
// If the element is set to some value, or if we are resolving a reference
// to a specific variable and that variable is explicitly unset, then
// replace the VarListElementInit with it.
- if (IRV || !dynamic_cast<const UnsetInit*>(E))
+ if (IRV || !dynamic_cast<UnsetInit*>(E))
return E;
return 0;
}
return 0;
}
-const Init *VarInit::getFieldInit(Record &R, const RecordVal *RV,
- const std::string &FieldName) const {
+Init *VarInit::getFieldInit(Record &R, const RecordVal *RV,
+ const std::string &FieldName) const {
if (dynamic_cast<RecordRecTy*>(getType()))
if (const RecordVal *Val = R.getValue(VarName)) {
- if (RV != Val && (RV || dynamic_cast<const UnsetInit*>(Val->getValue())))
+ if (RV != Val && (RV || dynamic_cast<UnsetInit*>(Val->getValue())))
return 0;
- const Init *TheInit = Val->getValue();
+ Init *TheInit = Val->getValue();
assert(TheInit != this && "Infinite loop detected!");
- if (const Init *I = TheInit->getFieldInit(R, RV, FieldName))
+ if (Init *I = TheInit->getFieldInit(R, RV, FieldName))
return I;
else
return 0;
/// If a value is set for the variable later, this method will be called on
/// users of the value to allow the value to propagate out.
///
-const Init *VarInit::resolveReferences(Record &R,
- const RecordVal *RV) const {
+Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) {
if (RecordVal *Val = R.getValue(VarName))
- if (RV == Val || (RV == 0
- && !dynamic_cast<const UnsetInit*>(Val->getValue())))
+ if (RV == Val || (RV == 0 && !dynamic_cast<UnsetInit*>(Val->getValue())))
return Val->getValue();
return this;
}
-const VarBitInit *VarBitInit::get(const TypedInit *T, unsigned B) {
- FoldingSetNodeID ID;
- ID.AddInteger(initVarBit);
- ID.AddPointer(T);
- ID.AddInteger(B);
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const VarBitInit *>(I);
-
- VarBitInit *I = InitAllocator.Allocate<VarBitInit>();
- new (I) VarBitInit(ID, T, B);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
-
std::string VarBitInit::getAsString() const {
return TI->getAsString() + "{" + utostr(Bit) + "}";
}
-const Init *
-VarBitInit::resolveReferences(Record &R,
- const RecordVal *RV) const {
- if (const Init *I = getVariable()->resolveBitReference(R, RV, getBitNum()))
+Init *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) {
+ if (Init *I = getVariable()->resolveBitReference(R, RV, getBitNum()))
return I;
return this;
}
-const VarListElementInit *VarListElementInit::get(const TypedInit *T,
- unsigned E) {
- FoldingSetNodeID ID;
- ID.AddInteger(initVarListElement);
- ID.AddPointer(T);
- ID.AddInteger(E);
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const VarListElementInit *>(I);
-
- VarListElementInit *I = InitAllocator.Allocate<VarListElementInit>();
- new (I) VarListElementInit(ID, T, E);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
-
std::string VarListElementInit::getAsString() const {
return TI->getAsString() + "[" + utostr(Element) + "]";
}
-const Init *VarListElementInit::resolveReferences(Record &R,
- const RecordVal *RV) const {
- if (const Init *I =
- getVariable()->resolveListElementReference(R, RV, getElementNum()))
+Init *VarListElementInit::resolveReferences(Record &R, const RecordVal *RV) {
+ if (Init *I = getVariable()->resolveListElementReference(R, RV,
+ getElementNum()))
return I;
return this;
}
-const Init *VarListElementInit::resolveBitReference(Record &R,
- const RecordVal *RV,
- unsigned Bit) const {
+Init *VarListElementInit::resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) {
// FIXME: This should be implemented, to support references like:
// bit B = AA[0]{1};
return 0;
}
-const Init *
-VarListElementInit::resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const {
+Init *VarListElementInit::
+resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) {
// FIXME: This should be implemented, to support references like:
// int B = AA[0][1];
return 0;
}
-const DefInit *DefInit::get(Record *D) {
- FoldingSetNodeID ID;
- ID.AddInteger(initDef);
- ID.AddString(D->getName());
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const DefInit *>(I);
-
- DefInit *I = InitAllocator.Allocate<DefInit>();
- new (I) DefInit(ID, D);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
-
RecTy *DefInit::getFieldType(const std::string &FieldName) const {
if (const RecordVal *RV = Def->getValue(FieldName))
return RV->getType();
return 0;
}
-const Init *DefInit::getFieldInit(Record &R, const RecordVal *RV,
- const std::string &FieldName) const {
+Init *DefInit::getFieldInit(Record &R, const RecordVal *RV,
+ const std::string &FieldName) const {
return Def->getValue(FieldName)->getValue();
}
return Def->getName();
}
-const FieldInit *FieldInit::get(const Init *R, const std::string &FN) {
- FoldingSetNodeID ID;
- ID.AddInteger(initField);
- ID.AddPointer(R);
- ID.AddString(FN);
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const FieldInit *>(I);
-
- FieldInit *I = InitAllocator.Allocate<FieldInit>();
- new (I) FieldInit(ID, R, FN);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
-
-const Init *FieldInit::resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const {
- if (const Init *BitsVal = Rec->getFieldInit(R, RV, FieldName))
- if (const BitsInit *BI = dynamic_cast<const BitsInit*>(BitsVal)) {
+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)) {
assert(Bit < BI->getNumBits() && "Bit reference out of range!");
- const Init *B = BI->getBit(Bit);
+ Init *B = BI->getBit(Bit);
- if (dynamic_cast<const BitInit*>(B)) // If the bit is set.
+ if (dynamic_cast<BitInit*>(B)) // If the bit is set.
return B; // Replace the VarBitInit with it.
}
return 0;
}
-const Init *FieldInit::resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const {
- if (const Init *ListVal = Rec->getFieldInit(R, RV, FieldName))
- if (const ListInit *LI = dynamic_cast<const ListInit*>(ListVal)) {
+Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) {
+ if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName))
+ if (ListInit *LI = dynamic_cast<ListInit*>(ListVal)) {
if (Elt >= LI->getSize()) return 0;
- const Init *E = LI->getElement(Elt);
+ Init *E = LI->getElement(Elt);
// If the element is set to some value, or if we are resolving a
// reference to a specific variable and that variable is explicitly
// unset, then replace the VarListElementInit with it.
- if (RV || !dynamic_cast<const UnsetInit*>(E))
+ if (RV || !dynamic_cast<UnsetInit*>(E))
return E;
}
return 0;
}
-const Init *FieldInit::resolveReferences(Record &R,
- const RecordVal *RV) const {
- const Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec;
+Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) {
+ Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec;
- const Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName);
+ Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName);
if (BitsVal) {
- const Init *BVR = BitsVal->resolveReferences(R, RV);
+ Init *BVR = BitsVal->resolveReferences(R, RV);
return BVR->isComplete() ? BVR : this;
}
if (NewRec != Rec) {
- return FieldInit::get(NewRec, FieldName);
+ return new FieldInit(NewRec, FieldName);
}
return this;
}
-const DagInit *
-DagInit::get(const Init *V, const std::string &VN,
- const std::vector<std::pair<const Init*, std::string> > &args) {
- FoldingSetNodeID ID;
- ID.AddInteger(initDag);
- ID.AddPointer(V);
- ID.AddString(VN);
-
- for (std::vector<std::pair<const Init*, std::string> >::const_iterator a
- = args.begin(),
- aend = args.end();
- a != aend;
- ++a) {
- ID.AddPointer(a->first);
- ID.AddString(a->second);
- }
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const DagInit *>(I);
-
- DagInit *I = InitAllocator.Allocate<DagInit>();
- new (I) DagInit(ID, V, VN, args);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
-
-const DagInit *
-DagInit::get(const Init *V, const std::string &VN,
- const std::vector<const Init *> &args,
- const std::vector<std::string> &argNames) {
- FoldingSetNodeID ID;
- ID.AddInteger(initDag);
- ID.AddPointer(V);
- ID.AddString(VN);
-
- std::vector<std::string>::const_iterator s = argNames.begin();
- for (std::vector<const Init*>::const_iterator a
- = args.begin(),
- aend = args.end();
- a != aend;
- ++a, ++s) {
- ID.AddPointer(*a);
- ID.AddString(*s);
- }
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const DagInit *>(I);
-
- DagInit *I = InitAllocator.Allocate<DagInit>();
- new (I) DagInit(ID, V, VN, args, argNames);
- UniqueInits.InsertNode(I, IP);
- return I;
-}
-
-const Init *DagInit::resolveReferences(Record &R,
- const RecordVal *RV) const {
- std::vector<const Init*> NewArgs;
+Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) {
+ std::vector<Init*> NewArgs;
for (unsigned i = 0, e = Args.size(); i != e; ++i)
NewArgs.push_back(Args[i]->resolveReferences(R, RV));
- const Init *Op = Val->resolveReferences(R, RV);
+ Init *Op = Val->resolveReferences(R, RV);
if (Args != NewArgs || Op != Val)
- return DagInit::get(Op, ValName, NewArgs, ArgNames);
+ return new DagInit(Op, ValName, NewArgs, ArgNames);
return this;
}
RecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P)
: Name(N), Ty(T), Prefix(P) {
- Value = Ty->convertValue(UnsetInit::get());
+ Value = Ty->convertValue(new UnsetInit());
assert(Value && "Cannot create unset value for current type!");
}
/// references.
void Record::resolveReferencesTo(const RecordVal *RV) {
for (unsigned i = 0, e = Values.size(); i != e; ++i) {
- if (const Init *V = Values[i].getValue())
+ if (Init *V = Values[i].getValue())
Values[i].setValue(V->resolveReferences(*this, RV));
}
}
/// getValueInit - Return the initializer for a value with the specified name,
/// or throw an exception if the field does not exist.
///
-const Init *Record::getValueInit(StringRef FieldName) const {
+Init *Record::getValueInit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
throw "Record `" + getName() + "' does not have a field named `" +
/// its value as a BitsInit, throwing an exception if the field does not exist
/// or if the value is not the right type.
///
-const BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
+BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n";
- if (const BitsInit *BI = dynamic_cast<const BitsInit*>(R->getValue()))
+ if (BitsInit *BI = dynamic_cast<BitsInit*>(R->getValue()))
return BI;
throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a BitsInit initializer!";
/// its value as a ListInit, throwing an exception if the field does not exist
/// or if the value is not the right type.
///
-const ListInit *Record::getValueAsListInit(StringRef FieldName) const {
+ListInit *Record::getValueAsListInit(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n";
- if (const ListInit *LI = dynamic_cast<const ListInit*>(R->getValue()))
+ if (ListInit *LI = dynamic_cast<ListInit*>(R->getValue()))
return LI;
throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a list initializer!";
///
std::vector<Record*>
Record::getValueAsListOfDefs(StringRef FieldName) const {
- const ListInit *List = getValueAsListInit(FieldName);
+ ListInit *List = getValueAsListInit(FieldName);
std::vector<Record*> Defs;
for (unsigned i = 0; i < List->getSize(); i++) {
- if (const DefInit *DI = dynamic_cast<const DefInit*>(List->getElement(i))) {
+ if (DefInit *DI = dynamic_cast<DefInit*>(List->getElement(i))) {
Defs.push_back(DI->getDef());
} else {
throw "Record `" + getName() + "', field `" + FieldName.str() +
throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n";
- if (const IntInit *II = dynamic_cast<const IntInit*>(R->getValue()))
+ if (IntInit *II = dynamic_cast<IntInit*>(R->getValue()))
return II->getValue();
throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have an int initializer!";
///
std::vector<int64_t>
Record::getValueAsListOfInts(StringRef FieldName) const {
- const ListInit *List = getValueAsListInit(FieldName);
+ ListInit *List = getValueAsListInit(FieldName);
std::vector<int64_t> Ints;
for (unsigned i = 0; i < List->getSize(); i++) {
- if (const IntInit *II = dynamic_cast<const IntInit*>(List->getElement(i))) {
+ if (IntInit *II = dynamic_cast<IntInit*>(List->getElement(i))) {
Ints.push_back(II->getValue());
} else {
throw "Record `" + getName() + "', field `" + FieldName.str() +
///
std::vector<std::string>
Record::getValueAsListOfStrings(StringRef FieldName) const {
- const ListInit *List = getValueAsListInit(FieldName);
+ ListInit *List = getValueAsListInit(FieldName);
std::vector<std::string> Strings;
for (unsigned i = 0; i < List->getSize(); i++) {
- if (const StringInit *II =
- dynamic_cast<const StringInit*>(List->getElement(i))) {
+ if (StringInit *II = dynamic_cast<StringInit*>(List->getElement(i))) {
Strings.push_back(II->getValue());
} else {
throw "Record `" + getName() + "', field `" + FieldName.str() +
throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n";
- if (const DefInit *DI = dynamic_cast<const DefInit*>(R->getValue()))
+ if (DefInit *DI = dynamic_cast<DefInit*>(R->getValue()))
return DI->getDef();
throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a def initializer!";
throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n";
- if (const BitInit *BI = dynamic_cast<const BitInit*>(R->getValue()))
+ if (BitInit *BI = dynamic_cast<BitInit*>(R->getValue()))
return BI->getValue();
throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a bit initializer!";
/// value as an Dag, throwing an exception if the field does not exist or if
/// the value is not the right type.
///
-const DagInit *Record::getValueAsDag(StringRef FieldName) const {
+DagInit *Record::getValueAsDag(StringRef FieldName) const {
const RecordVal *R = getValue(FieldName);
if (R == 0 || R->getValue() == 0)
throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n";
- if (const DagInit *DI = dynamic_cast<const DagInit*>(R->getValue()))
+ if (DagInit *DI = dynamic_cast<DagInit*>(R->getValue()))
return DI;
throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a dag initializer!";
#ifndef RECORD_H
#define RECORD_H
-#include "llvm/ADT/FoldingSet.h"
-#include "llvm/Support/Allocator.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/raw_ostream.h"
class RecordRecTy;
// Init subclasses.
-class Init;
+struct Init;
class UnsetInit;
class BitInit;
class BitsInit;
virtual bool typeIsConvertibleTo(const RecTy *RHS) const = 0;
public: // These methods should only be called from subclasses of Init
- virtual const Init *convertValue(const UnsetInit *UI) { return 0; }
- virtual const Init *convertValue(const BitInit *BI) { return 0; }
- virtual const Init *convertValue(const BitsInit *BI) { return 0; }
- virtual const Init *convertValue(const IntInit *II) { return 0; }
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue(const ListInit *LI) { return 0; }
- virtual const Init *convertValue(const UnOpInit *UI) {
- return convertValue((const TypedInit*)UI);
+ virtual 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 BinOpInit *UI) {
- return convertValue((const TypedInit*)UI);
+ virtual Init *convertValue( BinOpInit *UI) {
+ return convertValue((TypedInit*)UI);
}
- virtual const Init *convertValue(const TernOpInit *UI) {
- return convertValue((const TypedInit*)UI);
+ virtual Init *convertValue( TernOpInit *UI) {
+ return convertValue((TypedInit*)UI);
}
- virtual const Init *convertValue(const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue(const DefInit *DI) { return 0; }
- virtual const Init *convertValue(const DagInit *DI) { return 0; }
- virtual const Init *convertValue(const TypedInit *TI) { return 0; }
- virtual const Init *convertValue(const VarInit *VI) {
- return convertValue((const TypedInit*)VI);
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( TypedInit *TI) { return 0; }
+ virtual Init *convertValue( VarInit *VI) {
+ return convertValue((TypedInit*)VI);
}
- virtual const Init *convertValue(const FieldInit *FI) {
- return convertValue((const TypedInit*)FI);
+ virtual Init *convertValue( FieldInit *FI) {
+ return convertValue((TypedInit*)FI);
}
public: // These methods should only be called by subclasses of RecTy.
///
class BitRecTy : public RecTy {
public:
- virtual const Init *convertValue(const UnsetInit *UI) {
- return (const Init*)UI;
- }
- virtual const Init *convertValue(const BitInit *BI) {
- return (const Init*)BI;
- }
- virtual const Init *convertValue(const BitsInit *BI);
- virtual const Init *convertValue(const IntInit *II);
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue(const ListInit *LI) { return 0; }
- virtual const Init *convertValue(const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) {
- return (const Init*)VB;
- }
- virtual const Init *convertValue(const DefInit *DI) { return 0; }
- virtual const Init *convertValue(const DagInit *DI) { return 0; }
- virtual const Init *convertValue(const UnOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const BinOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const TernOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const TypedInit *TI);
- virtual const Init *convertValue(const VarInit *VI) {
- return RecTy::convertValue(VI);
- }
- virtual const Init *convertValue(const FieldInit *FI) {
- return RecTy::convertValue(FI);
- }
+ virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+ virtual Init *convertValue( BitInit *BI) { return (Init*)BI; }
+ virtual Init *convertValue( BitsInit *BI);
+ virtual Init *convertValue( IntInit *II);
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return (Init*)VB; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TypedInit *TI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "bit"; }
unsigned getNumBits() const { return Size; }
- virtual const Init *convertValue(const UnsetInit *UI);
- virtual const Init *convertValue(const BitInit *UI);
- virtual const Init *convertValue(const BitsInit *BI);
- virtual const Init *convertValue(const IntInit *II);
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue(const ListInit *LI) { return 0; }
- virtual const Init *convertValue(const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue(const DefInit *DI) { return 0; }
- virtual const Init *convertValue(const DagInit *DI) { return 0; }
- virtual const Init *convertValue(const UnOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const BinOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const TernOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const TypedInit *TI);
- virtual const Init *convertValue(const VarInit *VI) {
- return RecTy::convertValue(VI);
- }
- virtual const Init *convertValue(const FieldInit *FI) {
- return RecTy::convertValue(FI);
- }
+ virtual Init *convertValue( UnsetInit *UI);
+ virtual Init *convertValue( BitInit *UI);
+ virtual Init *convertValue( BitsInit *BI);
+ virtual Init *convertValue( IntInit *II);
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TypedInit *TI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const;
///
class IntRecTy : public RecTy {
public:
- virtual const Init *convertValue(const UnsetInit *UI) {
- return (const Init*)UI;
- }
- virtual const Init *convertValue(const BitInit *BI);
- virtual const Init *convertValue(const BitsInit *BI);
- virtual const Init *convertValue(const IntInit *II) {
- return (const Init*)II;
- }
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue(const ListInit *LI) { return 0; }
- virtual const Init *convertValue(const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue(const DefInit *DI) { return 0; }
- virtual const Init *convertValue(const DagInit *DI) { return 0; }
- virtual const Init *convertValue(const UnOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const BinOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const TernOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const TypedInit *TI);
- virtual const Init *convertValue(const VarInit *VI) {
- return RecTy::convertValue(VI);
- }
- virtual const Init *convertValue(const FieldInit *FI) {
- return RecTy::convertValue(FI);
- }
+ virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+ virtual Init *convertValue( BitInit *BI);
+ virtual Init *convertValue( BitsInit *BI);
+ virtual Init *convertValue( IntInit *II) { return (Init*)II; }
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TypedInit *TI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "int"; }
///
class StringRecTy : public RecTy {
public:
- virtual const Init *convertValue(const UnsetInit *UI) {
- return (const Init*)UI;
- }
- virtual const Init *convertValue(const BitInit *BI) { return 0; }
- virtual const Init *convertValue(const BitsInit *BI) { return 0; }
- virtual const Init *convertValue(const IntInit *II) { return 0; }
- virtual const Init *convertValue(const StringInit *SI) {
- return (const Init*)SI;
- }
- virtual const Init *convertValue(const ListInit *LI) { return 0; }
- virtual const Init *convertValue(const UnOpInit *BO);
- virtual const Init *convertValue(const BinOpInit *BO);
- virtual const Init *convertValue(const TernOpInit *BO) {
- return RecTy::convertValue(BO);
- }
-
- virtual const Init *convertValue(const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue(const DefInit *DI) { return 0; }
- virtual const Init *convertValue(const DagInit *DI) { return 0; }
- virtual const Init *convertValue(const TypedInit *TI);
- virtual const Init *convertValue(const VarInit *VI) {
- return RecTy::convertValue(VI);
- }
- virtual const Init *convertValue(const FieldInit *FI) {
- return RecTy::convertValue(FI);
- }
+ virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+ virtual Init *convertValue( BitInit *BI) { return 0; }
+ virtual Init *convertValue( BitsInit *BI) { return 0; }
+ virtual Init *convertValue( IntInit *II) { return 0; }
+ virtual Init *convertValue(StringInit *SI) { return (Init*)SI; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( UnOpInit *BO);
+ virtual Init *convertValue( BinOpInit *BO);
+ virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);}
+
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( TypedInit *TI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "string"; }
RecTy *getElementType() const { return Ty; }
- virtual const Init *convertValue(const UnsetInit *UI) {
- return (const Init*)UI;
- }
- virtual const Init *convertValue(const BitInit *BI) { return 0; }
- virtual const Init *convertValue(const BitsInit *BI) { return 0; }
- virtual const Init *convertValue(const IntInit *II) { return 0; }
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue(const ListInit *LI);
- virtual const Init *convertValue(const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue(const DefInit *DI) { return 0; }
- virtual const Init *convertValue(const DagInit *DI) { return 0; }
- virtual const Init *convertValue(const UnOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const BinOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const TernOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const TypedInit *TI);
- virtual const Init *convertValue(const VarInit *VI) {
- return RecTy::convertValue(VI);
- }
- virtual const Init *convertValue(const FieldInit *FI) {
- return RecTy::convertValue(FI);
- }
+ virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+ virtual Init *convertValue( BitInit *BI) { return 0; }
+ virtual Init *convertValue( BitsInit *BI) { return 0; }
+ virtual Init *convertValue( IntInit *II) { return 0; }
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI);
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TypedInit *TI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const;
///
class CodeRecTy : public RecTy {
public:
- virtual const Init *convertValue(const UnsetInit *UI) {
- return (const Init*)UI;
- }
- virtual const Init *convertValue(const BitInit *BI) { return 0; }
- virtual const Init *convertValue(const BitsInit *BI) { return 0; }
- virtual const Init *convertValue(const IntInit *II) { return 0; }
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue(const ListInit *LI) { return 0; }
- virtual const Init *convertValue(const CodeInit *CI) {
- return (const Init*)CI;
- }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue(const DefInit *DI) { return 0; }
- virtual const Init *convertValue(const DagInit *DI) { return 0; }
- virtual const Init *convertValue(const UnOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const BinOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const TernOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const TypedInit *TI);
- virtual const Init *convertValue(const VarInit *VI) {
- return RecTy::convertValue(VI);
- }
- virtual const Init *convertValue(const FieldInit *FI) {
- return RecTy::convertValue(FI);
- }
+ virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+ virtual Init *convertValue( BitInit *BI) { return 0; }
+ virtual Init *convertValue( BitsInit *BI) { return 0; }
+ virtual Init *convertValue( IntInit *II) { return 0; }
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( CodeInit *CI) { return (Init*)CI; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TypedInit *TI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "code"; }
///
class DagRecTy : public RecTy {
public:
- virtual const Init *convertValue(const UnsetInit *UI) {
- return (const Init*)UI;
- }
- virtual const Init *convertValue(const BitInit *BI) { return 0; }
- virtual const Init *convertValue(const BitsInit *BI) { return 0; }
- virtual const Init *convertValue(const IntInit *II) { return 0; }
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue(const ListInit *LI) { return 0; }
- virtual const Init *convertValue(const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue(const DefInit *DI) { return 0; }
- virtual const Init *convertValue(const UnOpInit *BO);
- virtual const Init *convertValue(const BinOpInit *BO);
- virtual const Init *convertValue(const TernOpInit *BO) {
- return RecTy::convertValue(BO);
- }
- virtual const Init *convertValue(const DagInit *CI) {
- return (const Init*)CI;
- }
- virtual const Init *convertValue(const TypedInit *TI);
- virtual const Init *convertValue(const VarInit *VI) {
- return RecTy::convertValue(VI);
- }
- virtual const Init *convertValue(const FieldInit *FI) {
- return RecTy::convertValue(FI);
- }
+ virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+ virtual Init *convertValue( BitInit *BI) { return 0; }
+ virtual Init *convertValue( BitsInit *BI) { return 0; }
+ virtual Init *convertValue( IntInit *II) { return 0; }
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( DefInit *DI) { return 0; }
+ virtual Init *convertValue( UnOpInit *BO);
+ virtual Init *convertValue( BinOpInit *BO);
+ virtual Init *convertValue( TernOpInit *BO) { return RecTy::convertValue(BO);}
+ virtual Init *convertValue( DagInit *CI) { return (Init*)CI; }
+ virtual Init *convertValue( TypedInit *TI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const { return "dag"; }
Record *getRecord() const { return Rec; }
- virtual const Init *convertValue(const UnsetInit *UI) {
- return (const Init*)UI;
- }
- virtual const Init *convertValue(const BitInit *BI) { return 0; }
- virtual const Init *convertValue(const BitsInit *BI) { return 0; }
- virtual const Init *convertValue(const IntInit *II) { return 0; }
- virtual const Init *convertValue(const StringInit *SI) { return 0; }
- virtual const Init *convertValue(const ListInit *LI) { return 0; }
- virtual const Init *convertValue(const CodeInit *CI) { return 0; }
- virtual const Init *convertValue(const VarBitInit *VB) { return 0; }
- virtual const Init *convertValue(const UnOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const BinOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const TernOpInit *UI) {
- return RecTy::convertValue(UI);
- }
- virtual const Init *convertValue(const DefInit *DI);
- virtual const Init *convertValue(const DagInit *DI) { return 0; }
- virtual const Init *convertValue(const TypedInit *VI);
- virtual const Init *convertValue(const VarInit *VI) {
- return RecTy::convertValue(VI);
- }
- virtual const Init *convertValue(const FieldInit *FI) {
- return RecTy::convertValue(FI);
- }
+ virtual Init *convertValue( UnsetInit *UI) { return (Init*)UI; }
+ virtual Init *convertValue( BitInit *BI) { return 0; }
+ virtual Init *convertValue( BitsInit *BI) { return 0; }
+ virtual Init *convertValue( IntInit *II) { return 0; }
+ virtual Init *convertValue(StringInit *SI) { return 0; }
+ virtual Init *convertValue( ListInit *LI) { return 0; }
+ virtual Init *convertValue( CodeInit *CI) { return 0; }
+ virtual Init *convertValue(VarBitInit *VB) { return 0; }
+ virtual Init *convertValue( UnOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( BinOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( TernOpInit *UI) { return RecTy::convertValue(UI);}
+ virtual Init *convertValue( DefInit *DI);
+ virtual Init *convertValue( DagInit *DI) { return 0; }
+ virtual Init *convertValue( TypedInit *VI);
+ virtual Init *convertValue( VarInit *VI) { return RecTy::convertValue(VI);}
+ virtual Init *convertValue( FieldInit *FI) { return RecTy::convertValue(FI);}
std::string getAsString() const;
// Initializer Classes
//===----------------------------------------------------------------------===//
-class Init : public FastFoldingSetNode {
- Init(const Init &); // Do not define.
- Init &operator=(const Init &); // Do not define.
-
-protected:
- Init(const FoldingSetNodeID &ID) : FastFoldingSetNode(ID) {}
-
- static FoldingSet<Init> UniqueInits;
- static BumpPtrAllocator InitAllocator;
-
- enum Type {
- initUnset,
- initBit,
- initBits,
- initInt,
- initString,
- initCode,
- initList,
- initUnOp,
- initBinOp,
- initTernOp,
- initQuadOp,
- initVar,
- initVarBit,
- initVarListElement,
- initDef,
- initField,
- initDag
- };
-
-public:
+struct Init {
virtual ~Init() {}
- static void ReleaseMemory() {
- InitAllocator.Reset();
- }
-
/// isComplete - This virtual method should be overridden by values that may
/// not be completely specified yet.
virtual bool isComplete() const { return true; }
/// function that should be overridden to call the appropriate
/// RecTy::convertValue method.
///
- virtual const Init *convertInitializerTo(RecTy *Ty) const = 0;
+ virtual Init *convertInitializerTo(RecTy *Ty) = 0;
/// convertInitializerBitRange - This method is used to implement the bitrange
/// selection operator. Given an initializer, it selects the specified bits
/// out, returning them as a new init of bits type. If it is not legal to use
/// the bit subscript operator on this initializer, return null.
///
- virtual const Init *
- convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
+ virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits) {
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 const Init *
- convertInitListSlice(const std::vector<unsigned> &Elements) const {
+ virtual Init *convertInitListSlice(const std::vector<unsigned> &Elements) {
return 0;
}
/// initializer for the specified field. If getFieldType returns non-null
/// this method should return non-null, otherwise it returns null.
///
- virtual const Init *getFieldInit(Record &R, const RecordVal *RV,
- const std::string &FieldName) const {
+ virtual Init *getFieldInit(Record &R, const RecordVal *RV,
+ const std::string &FieldName) const {
return 0;
}
/// If a value is set for the variable later, this method will be called on
/// users of the value to allow the value to propagate out.
///
- virtual const Init *resolveReferences(Record &R,
- const RecordVal *RV) const {
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV) {
return this;
}
};
///
class TypedInit : public Init {
RecTy *Ty;
-
- TypedInit(const TypedInit &Other); // Do not define.
- TypedInit &operator=(const TypedInit &Other); // Do not define.
-
-protected:
- explicit TypedInit(const FoldingSetNodeID &ID, RecTy *T) : Init(ID), Ty(T) {}
-
public:
+ explicit TypedInit(RecTy *T) : Ty(T) {}
+
RecTy *getType() const { return Ty; }
- virtual const Init *
- convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
- virtual const Init *
- convertInitListSlice(const std::vector<unsigned> &Elements) const;
+ virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
+ virtual Init *convertInitListSlice(const std::vector<unsigned> &Elements);
/// 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 const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const = 0;
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) = 0;
/// resolveListElementReference - This method is used to implement
/// VarListElementInit::resolveReferences. If the list element is resolvable
/// now, we return the resolved value, otherwise we return null.
- virtual const Init *resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const = 0;
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) = 0;
};
/// UnsetInit - ? - Represents an uninitialized value
///
class UnsetInit : public Init {
- UnsetInit(const FoldingSetNodeID &ID) : Init(ID) {}
- UnsetInit(const UnsetInit &); // Do not define.
- UnsetInit &operator=(const UnsetInit &Other); // Do not define.
-
public:
- static const UnsetInit *get();
-
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
///
class BitInit : public Init {
bool Value;
-
- explicit BitInit(const FoldingSetNodeID &ID, bool V) : Init(ID), Value(V) {}
- BitInit(const BitInit &Other); // Do not define.
- BitInit &operator=(BitInit &Other); // Do not define.
-
public:
- static const BitInit *get(bool V);
+ explicit BitInit(bool V) : Value(V) {}
bool getValue() const { return Value; }
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
/// It contains a vector of bits, whose size is determined by the type.
///
class BitsInit : public Init {
- std::vector<const Init*> Bits;
-
- BitsInit(const FoldingSetNodeID &ID, unsigned Size)
- : Init(ID), Bits(Size) {}
-
- template<typename InputIterator>
- BitsInit(const FoldingSetNodeID &ID, InputIterator start, InputIterator end)
- : Init(ID), Bits(start, end) {}
-
- BitsInit(const BitsInit &Other); // Do not define.
- BitsInit &operator=(const BitsInit &Other); // Do not define.
-
+ std::vector<Init*> Bits;
public:
- template<typename InputIterator>
- static const BitsInit *get(InputIterator Start, InputIterator End) {
- FoldingSetNodeID ID;
- ID.AddInteger(initBits);
- ID.AddInteger(std::distance(Start, End));
-
- InputIterator S = Start;
- while (S != End)
- ID.AddPointer(*S++);
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const BitsInit *>(I);
-
- BitsInit *I = InitAllocator.Allocate<BitsInit>();
- new (I) BitsInit(ID, Start, End);
- UniqueInits.InsertNode(I, IP);
- return I;
- }
+ explicit BitsInit(unsigned Size) : Bits(Size) {}
unsigned getNumBits() const { return Bits.size(); }
- const Init *getBit(unsigned Bit) const {
+ Init *getBit(unsigned Bit) const {
assert(Bit < Bits.size() && "Bit index out of range!");
return Bits[Bit];
}
- void setBit(unsigned Bit, const Init *V) {
+ void setBit(unsigned Bit, Init *V) {
assert(Bit < Bits.size() && "Bit index out of range!");
assert(Bits[Bit] == 0 && "Bit already set!");
Bits[Bit] = V;
}
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
- virtual const Init *
- convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
+ virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
virtual bool isComplete() const {
for (unsigned i = 0; i != getNumBits(); ++i)
}
virtual std::string getAsString() const;
- virtual const Init *resolveReferences(Record &R,
- const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV);
};
///
class IntInit : public TypedInit {
int64_t Value;
-
- explicit IntInit(const FoldingSetNodeID &ID, int64_t V)
- : TypedInit(ID, new IntRecTy), Value(V) {}
-
- IntInit(const IntInit &Other); // Do not define.
- IntInit &operator=(const IntInit &Other); // Do note define.
-
public:
- static const IntInit *get(int64_t V);
+ explicit IntInit(int64_t V) : TypedInit(new IntRecTy), Value(V) {}
int64_t getValue() const { return Value; }
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
- virtual const Init *
- convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
+ virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
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 const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const {
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) {
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 const Init *resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const {
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) {
assert(0 && "Illegal element reference off int");
return 0;
}
///
class StringInit : public TypedInit {
std::string Value;
-
- explicit StringInit(const FoldingSetNodeID &ID, const std::string &V)
- : TypedInit(ID, new StringRecTy), Value(V) {}
-
- StringInit(const StringInit &Other); // Do not define.
- StringInit &operator=(const StringInit &Other); // Do not define.
-
public:
- static const StringInit *get(const std::string &V);
+ explicit StringInit(const std::string &V)
+ : TypedInit(new StringRecTy), Value(V) {}
const std::string &getValue() const { return Value; }
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
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 const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const {
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) {
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 const Init *resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const {
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) {
assert(0 && "Illegal element reference off string");
return 0;
}
///
class CodeInit : public Init {
std::string Value;
-
- explicit CodeInit(const FoldingSetNodeID &ID, const std::string &V)
- : Init(ID), Value(V) {}
-
- CodeInit(const CodeInit &Other); // Do not define.
- CodeInit &operator=(const CodeInit &Other); // Do not define.
-
public:
- static const CodeInit *get(const std::string &V);
+ explicit CodeInit(const std::string &V) : Value(V) {}
const std::string &getValue() const { return Value; }
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
/// ListInit - [AL, AH, CL] - Represent a list of defs
///
class ListInit : public TypedInit {
- std::vector<const Init*> Values;
-
+ std::vector<Init*> Values;
public:
- typedef std::vector<const Init*>::const_iterator const_iterator;
+ typedef std::vector<Init*>::iterator iterator;
+ typedef std::vector<Init*>::const_iterator const_iterator;
-private:
- ListInit(const FoldingSetNodeID &ID, std::vector<const Init*> &Vs,
- RecTy *EltTy)
- : TypedInit(ID, new ListRecTy(EltTy)) {
+ explicit ListInit(std::vector<Init*> &Vs, RecTy *EltTy)
+ : TypedInit(new ListRecTy(EltTy)) {
Values.swap(Vs);
}
-
- template<typename InputIterator>
- ListInit(const FoldingSetNodeID &ID, InputIterator Start, InputIterator End,
- RecTy *EltTy)
- : TypedInit(ID, new ListRecTy(EltTy)), Values(Start, End) {}
-
- ListInit(const ListInit &Other); // Do not define.
- ListInit &operator=(const ListInit &Other); // Do not define.
-
-public:
- static const ListInit *get(std::vector<const Init*> &Vs, RecTy *EltTy);
-
- template<typename InputIterator>
- static const ListInit *get(InputIterator Start, InputIterator End,
- RecTy *EltTy) {
- FoldingSetNodeID ID;
- ID.AddInteger(initList);
- ID.AddString(EltTy->getAsString());
-
- InputIterator S = Start;
- while (S != End)
- ID.AddPointer(*S++);
-
- void *IP = 0;
- if (const Init *I = UniqueInits.FindNodeOrInsertPos(ID, IP))
- return static_cast<const ListInit *>(I);
-
- ListInit *I = InitAllocator.Allocate<ListInit>();
- new (I) ListInit(ID, Start, End, EltTy);
- UniqueInits.InsertNode(I, IP);
- return I;
- }
+ explicit ListInit(iterator Start, iterator End, RecTy *EltTy)
+ : TypedInit(new ListRecTy(EltTy)), Values(Start, End) {}
unsigned getSize() const { return Values.size(); }
- const Init *getElement(unsigned i) const {
+ Init *getElement(unsigned i) const {
assert(i < Values.size() && "List element index out of range!");
return Values[i];
}
Record *getElementAsRecord(unsigned i) const;
- const Init *convertInitListSlice(const std::vector<unsigned> &Elements) const;
+ Init *convertInitListSlice(const std::vector<unsigned> &Elements);
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
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 const Init *resolveReferences(Record &R,
- const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV);
virtual std::string getAsString() const;
+ inline iterator begin() { return Values.begin(); }
inline const_iterator begin() const { return Values.begin(); }
+ inline iterator end () { return Values.end(); }
inline const_iterator end () const { return Values.end(); }
inline size_t size () const { return Values.size(); }
/// VarBitInit::resolveReferences. If the bit is able to be resolved, we
/// simply return the resolved value, otherwise we return null.
///
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const {
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) {
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 const Init *resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const;
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt);
};
/// OpInit - Base class for operators
///
class OpInit : public TypedInit {
- OpInit(const OpInit &Other); // Do not define.
- OpInit &operator=(OpInit &Other); // Do not define.
-
-protected:
- explicit OpInit(const FoldingSetNodeID &ID, RecTy *Type)
- : TypedInit(ID, Type) {}
-
public:
+ OpInit(RecTy *Type) : TypedInit(Type) {}
+
// Clone - Clone this operator, replacing arguments with the new list
- virtual const OpInit *clone(std::vector<const Init *> &Operands) const = 0;
+ virtual OpInit *clone(std::vector<Init *> &Operands) = 0;
virtual int getNumOperands() const = 0;
- virtual const Init *getOperand(int i) const = 0;
+ virtual Init *getOperand(int i) = 0;
// Fold - If possible, fold this to a simpler init. Return this if not
// possible to fold.
- virtual const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0;
+ virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) = 0;
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const;
- virtual const Init *resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const;
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit);
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt);
};
enum UnaryOp { CAST, HEAD, TAIL, EMPTY };
private:
UnaryOp Opc;
- const Init *LHS;
-
- UnOpInit(const FoldingSetNodeID &ID, UnaryOp opc, const Init *lhs,
- RecTy *Type)
- : OpInit(ID, Type), Opc(opc), LHS(lhs) {}
-
- UnOpInit(const UnOpInit &Other); // Do not define.
- UnOpInit &operator=(const UnOpInit &Other); // Do not define.
-
+ Init *LHS;
public:
- static const UnOpInit *get(UnaryOp opc, const Init *lhs, RecTy *Type);
+ UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type) :
+ OpInit(Type), Opc(opc), LHS(lhs) {
+ }
// Clone - Clone this operator, replacing arguments with the new list
- virtual const OpInit *clone(std::vector<const Init *> &Operands) const {
+ virtual OpInit *clone(std::vector<Init *> &Operands) {
assert(Operands.size() == 1 &&
"Wrong number of operands for unary operation");
- return UnOpInit::get(getOpcode(), *Operands.begin(), getType());
+ return new UnOpInit(getOpcode(), *Operands.begin(), getType());
}
int getNumOperands() const { return 1; }
- const Init *getOperand(int i) const {
+ Init *getOperand(int i) {
assert(i == 0 && "Invalid operand id for unary operator");
return getOperand();
}
UnaryOp getOpcode() const { return Opc; }
- const Init *getOperand() const { return LHS; }
+ Init *getOperand() const { return LHS; }
// Fold - If possible, fold this to a simpler init. Return this if not
// possible to fold.
- const Init *Fold(Record *CurRec, MultiClass *CurMultiClass)const ;
+ Init *Fold(Record *CurRec, MultiClass *CurMultiClass);
- virtual const Init *resolveReferences(Record &R,
- const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV);
virtual std::string getAsString() const;
};
enum BinaryOp { SHL, SRA, SRL, STRCONCAT, CONCAT, EQ };
private:
BinaryOp Opc;
- const Init *LHS, *RHS;
-
- BinOpInit(const FoldingSetNodeID &ID, BinaryOp opc, const Init *lhs,
- const Init *rhs, RecTy *Type) :
- OpInit(ID, Type), Opc(opc), LHS(lhs), RHS(rhs) {}
-
- BinOpInit(const BinOpInit &Other); // Do not define.
- BinOpInit &operator=(const BinOpInit &Other); // Do not define.
-
+ Init *LHS, *RHS;
public:
- static const BinOpInit *get(BinaryOp opc, const Init *lhs, const Init *rhs,
- RecTy *Type);
+ BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
+ OpInit(Type), Opc(opc), LHS(lhs), RHS(rhs) {
+ }
// Clone - Clone this operator, replacing arguments with the new list
- virtual const OpInit *clone(std::vector<const Init *> &Operands) const {
+ virtual OpInit *clone(std::vector<Init *> &Operands) {
assert(Operands.size() == 2 &&
"Wrong number of operands for binary operation");
- return BinOpInit::get(getOpcode(), Operands[0], Operands[1], getType());
+ return new BinOpInit(getOpcode(), Operands[0], Operands[1], getType());
}
int getNumOperands() const { return 2; }
- const Init *getOperand(int i) const {
+ Init *getOperand(int i) {
assert((i == 0 || i == 1) && "Invalid operand id for binary operator");
if (i == 0) {
return getLHS();
}
BinaryOp getOpcode() const { return Opc; }
- const Init *getLHS() const { return LHS; }
- const Init *getRHS() const { return RHS; }
+ Init *getLHS() const { return LHS; }
+ Init *getRHS() const { return RHS; }
// Fold - If possible, fold this to a simpler init. Return this if not
// possible to fold.
- const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
+ Init *Fold(Record *CurRec, MultiClass *CurMultiClass);
- virtual const Init *resolveReferences(Record &R,
- const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV);
virtual std::string getAsString() const;
};
enum TernaryOp { SUBST, FOREACH, IF };
private:
TernaryOp Opc;
- const Init *LHS, *MHS, *RHS;
-
- TernOpInit(const FoldingSetNodeID &ID, TernaryOp opc, const Init *lhs,
- const Init *mhs, const Init *rhs, RecTy *Type) :
- OpInit(ID, Type), Opc(opc), LHS(lhs), MHS(mhs), RHS(rhs) {}
-
- TernOpInit(const TernOpInit &Other); // Do not define.
- TernOpInit &operator=(const TernOpInit &Other); // Do not define.
-
+ Init *LHS, *MHS, *RHS;
public:
- static const TernOpInit *get(TernaryOp opc, const Init *lhs,
- const Init *mhs, const Init *rhs,
- RecTy *Type);
+ TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, 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 const OpInit *clone(std::vector<const Init *> &Operands) const {
+ virtual OpInit *clone(std::vector<Init *> &Operands) {
assert(Operands.size() == 3 &&
"Wrong number of operands for ternary operation");
- return TernOpInit::get(getOpcode(), Operands[0], Operands[1],
- Operands[2], getType());
+ return new TernOpInit(getOpcode(), Operands[0], Operands[1], Operands[2],
+ getType());
}
int getNumOperands() const { return 3; }
- const Init *getOperand(int i) const {
+ Init *getOperand(int i) {
assert((i == 0 || i == 1 || i == 2) &&
"Invalid operand id for ternary operator");
if (i == 0) {
}
TernaryOp getOpcode() const { return Opc; }
- const Init *getLHS() const { return LHS; }
- const Init *getMHS() const { return MHS; }
- const Init *getRHS() const { return RHS; }
+ Init *getLHS() const { return LHS; }
+ Init *getMHS() const { return MHS; }
+ Init *getRHS() const { return RHS; }
// Fold - If possible, fold this to a simpler init. Return this if not
// possible to fold.
- const Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const;
+ Init *Fold(Record *CurRec, MultiClass *CurMultiClass);
virtual bool isComplete() const { return false; }
- virtual const Init *resolveReferences(Record &R,
- const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV);
virtual std::string getAsString() const;
};
///
class VarInit : public TypedInit {
std::string VarName;
-
- explicit VarInit(const FoldingSetNodeID &ID, const std::string &VN, RecTy *T)
- : TypedInit(ID, T), VarName(VN) {}
-
- VarInit(const VarInit &Other); // Do not define.
- VarInit &operator=(const VarInit &Other); // Do not define.
-
public:
- static const VarInit *get(const std::string &VN, RecTy *T);
- static const VarInit *get(const Init *VN, RecTy *T);
+ explicit VarInit(const std::string &VN, RecTy *T)
+ : TypedInit(T), VarName(VN) {}
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
const std::string &getName() const { return VarName; }
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const;
- virtual const Init *resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const;
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit);
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt);
virtual RecTy *getFieldType(const std::string &FieldName) const;
- virtual const Init *getFieldInit(Record &R, const RecordVal *RV,
+ virtual Init *getFieldInit(Record &R, const RecordVal *RV,
const std::string &FieldName) const;
/// resolveReferences - This method is used by classes that refer to other
/// If a value is set for the variable later, this method will be called on
/// users of the value to allow the value to propagate out.
///
- virtual const Init *resolveReferences(Record &R,
- const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV);
virtual std::string getAsString() const { return VarName; }
};
/// VarBitInit - Opcode{0} - Represent access to one bit of a variable or field.
///
class VarBitInit : public Init {
- const TypedInit *TI;
+ TypedInit *TI;
unsigned Bit;
-
- VarBitInit(const FoldingSetNodeID &ID, const TypedInit *T, unsigned B)
- : Init(ID), TI(T), Bit(B) {
+public:
+ VarBitInit(TypedInit *T, unsigned B) : TI(T), Bit(B) {
assert(T->getType() && dynamic_cast<BitsRecTy*>(T->getType()) &&
((BitsRecTy*)T->getType())->getNumBits() > B &&
"Illegal VarBitInit expression!");
}
- VarBitInit(const VarBitInit &Other); // Do not define.
- VarBitInit &operator=(const VarBitInit &Other); // Do not define.
-
-public:
- static const VarBitInit *get(const TypedInit *T, unsigned B);
-
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
- const TypedInit *getVariable() const { return TI; }
+ TypedInit *getVariable() const { return TI; }
unsigned getBitNum() const { return Bit; }
virtual std::string getAsString() const;
- virtual const Init *resolveReferences(Record &R,
- const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV);
};
/// VarListElementInit - List[4] - Represent access to one element of a var or
/// field.
class VarListElementInit : public TypedInit {
- const TypedInit *TI;
+ TypedInit *TI;
unsigned Element;
-
- VarListElementInit(const FoldingSetNodeID &ID, const TypedInit *T, unsigned E)
- : TypedInit(ID, dynamic_cast<ListRecTy*>(T->getType())->getElementType()),
+public:
+ VarListElementInit(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!");
}
- VarListElementInit(const VarListElementInit &Other); // Do not define.
- VarListElementInit &operator=(const VarListElementInit &Other); // Do
- // not
- // define.
-
-public:
- static const VarListElementInit *get(const TypedInit *T, unsigned E);
-
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
- const TypedInit *getVariable() const { return TI; }
+ TypedInit *getVariable() const { return TI; }
unsigned getElementNum() const { return Element; }
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const;
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit);
/// resolveListElementReference - This method is used to implement
/// VarListElementInit::resolveReferences. If the list element is resolvable
/// now, we return the resolved value, otherwise we return null.
- virtual const Init *resolveListElementReference(Record &R, const RecordVal *RV,
- unsigned Elt) const;
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt);
virtual std::string getAsString() const;
- virtual const Init *resolveReferences(Record &R,
- const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV);
};
/// DefInit - AL - Represent a reference to a 'def' in the description
///
class DefInit : public TypedInit {
Record *Def;
-
- explicit DefInit(const FoldingSetNodeID &ID, Record *D)
- : TypedInit(ID, new RecordRecTy(D)), Def(D) {}
-
- DefInit(const DefInit &Other); // Do not define.
- DefInit &operator=(const DefInit &Other); // Do not define.
-
public:
- static const DefInit *get(Record *D);
+ explicit DefInit(Record *D) : TypedInit(new RecordRecTy(D)), Def(D) {}
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
Record *getDef() const { return Def; }
- //virtual const Init *
- //convertInitializerBitRange(const std::vector<unsigned> &Bits) const;
+ //virtual Init *convertInitializerBitRange(const std::vector<unsigned> &Bits);
virtual RecTy *getFieldType(const std::string &FieldName) const;
- virtual const Init *getFieldInit(Record &R, const RecordVal *RV,
+ virtual 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 const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const {
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) {
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 const Init *resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const {
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) {
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 {
- const Init *Rec; // Record we are referring to
+ Init *Rec; // Record we are referring to
std::string FieldName; // Field we are accessing
-
- FieldInit(const FoldingSetNodeID &ID, const Init *R, const std::string &FN)
- : TypedInit(ID, R->getFieldType(FN)), Rec(R), FieldName(FN) {
+public:
+ FieldInit(Init *R, const std::string &FN)
+ : TypedInit(R->getFieldType(FN)), Rec(R), FieldName(FN) {
assert(getType() && "FieldInit with non-record type!");
}
- FieldInit(const FieldInit &Other); // Do not define.
- FieldInit &operator=(const FieldInit &Other); // Do not define.
-
-public:
- static const FieldInit *get(const Init *R, const std::string &FN);
- static const FieldInit *get(const Init *R, const Init *FN);
-
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const;
- virtual const Init *resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const;
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit);
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt);
- virtual const Init *resolveReferences(Record &R,
- const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV);
virtual std::string getAsString() const {
return Rec->getAsString() + "." + FieldName;
/// argument can have a name associated with it.
///
class DagInit : public TypedInit {
- const Init *Val;
+ Init *Val;
std::string ValName;
- std::vector<const Init*> Args;
+ std::vector<Init*> Args;
std::vector<std::string> ArgNames;
-
- DagInit(const FoldingSetNodeID &ID, const Init *V, const std::string &VN,
- const std::vector<std::pair<const Init*, std::string> > &args)
- : TypedInit(ID, new DagRecTy), Val(V), ValName(VN) {
+public:
+ DagInit(Init *V, std::string VN,
+ const std::vector<std::pair<Init*, std::string> > &args)
+ : TypedInit(new DagRecTy), Val(V), ValName(VN) {
Args.reserve(args.size());
ArgNames.reserve(args.size());
for (unsigned i = 0, e = args.size(); i != e; ++i) {
ArgNames.push_back(args[i].second);
}
}
- DagInit(const FoldingSetNodeID &ID, const Init *V, const std::string &VN,
- const std::vector<const Init*> &args,
+ DagInit(Init *V, std::string VN, const std::vector<Init*> &args,
const std::vector<std::string> &argNames)
- : TypedInit(ID, new DagRecTy), Val(V), ValName(VN), Args(args),
+ : TypedInit(new DagRecTy), Val(V), ValName(VN), Args(args),
ArgNames(argNames) { }
- DagInit(const DagInit &Other); // Do not define.
- DagInit &operator=(const DagInit &Other); // Do not define.
-
-public:
- static const DagInit *get(const Init *V, const std::string &VN,
- const std::vector<
- std::pair<const Init*, std::string> > &args);
- static const DagInit *get(const Init *V, const std::string &VN,
- const std::vector<const Init*> &args,
- const std::vector<std::string> &argNames);
-
- virtual const Init *convertInitializerTo(RecTy *Ty) const {
+ virtual Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
}
- const Init *getOperator() const { return Val; }
+ Init *getOperator() const { return Val; }
const std::string &getName() const { return ValName; }
unsigned getNumArgs() const { return Args.size(); }
- const Init *getArg(unsigned Num) const {
+ Init *getArg(unsigned Num) const {
assert(Num < Args.size() && "Arg number out of range!");
return Args[Num];
}
return ArgNames[Num];
}
- void setArg(unsigned Num, const Init *I) {
+ void setArg(unsigned Num, Init *I) {
assert(Num < Args.size() && "Arg number out of range!");
Args[Num] = I;
}
- virtual const Init *resolveReferences(Record &R,
- const RecordVal *RV) const;
+ virtual Init *resolveReferences(Record &R, const RecordVal *RV);
virtual std::string getAsString() const;
- typedef std::vector<const Init*>::iterator arg_iterator;
- typedef std::vector<const Init*>::const_iterator const_arg_iterator;
+ typedef std::vector<Init*>::iterator arg_iterator;
+ typedef std::vector<Init*>::const_iterator const_arg_iterator;
typedef std::vector<std::string>::iterator name_iterator;
typedef std::vector<std::string>::const_iterator const_name_iterator;
inline size_t name_size () const { return ArgNames.size(); }
inline bool name_empty() const { return ArgNames.empty(); }
- virtual const Init *resolveBitReference(Record &R, const RecordVal *RV,
- unsigned Bit) const {
+ virtual Init *resolveBitReference(Record &R, const RecordVal *RV,
+ unsigned Bit) {
assert(0 && "Illegal bit reference off dag");
return 0;
}
- virtual const Init *resolveListElementReference(Record &R,
- const RecordVal *RV,
- unsigned Elt) const {
+ virtual Init *resolveListElementReference(Record &R, const RecordVal *RV,
+ unsigned Elt) {
assert(0 && "Illegal element reference off dag");
return 0;
}
std::string Name;
RecTy *Ty;
unsigned Prefix;
- const Init *Value;
+ Init *Value;
public:
RecordVal(const std::string &N, RecTy *T, unsigned P);
unsigned getPrefix() const { return Prefix; }
RecTy *getType() const { return Ty; }
- const Init *getValue() const { return Value; }
+ Init *getValue() const { return Value; }
- bool setValue(const Init *V) {
+ bool setValue(Init *V) {
if (V) {
Value = V->convertInitializerTo(Ty);
return Value == 0;
/// getValueInit - Return the initializer for a value with the specified name,
/// or throw an exception if the field does not exist.
///
- const Init *getValueInit(StringRef FieldName) const;
+ Init *getValueInit(StringRef FieldName) const;
/// getValueAsString - This method looks up the specified field and returns
/// its value as a string, throwing an exception if the field does not exist
/// its value as a BitsInit, throwing an exception if the field does not exist
/// or if the value is not the right type.
///
- const BitsInit *getValueAsBitsInit(StringRef FieldName) const;
+ BitsInit *getValueAsBitsInit(StringRef FieldName) const;
/// getValueAsListInit - This method looks up the specified field and returns
/// its value as a ListInit, throwing an exception if the field does not exist
/// or if the value is not the right type.
///
- const ListInit *getValueAsListInit(StringRef FieldName) const;
+ ListInit *getValueAsListInit(StringRef FieldName) const;
/// getValueAsListOfDefs - This method looks up the specified field and
/// returns its value as a vector of records, throwing an exception if the
/// value as an Dag, throwing an exception if the field does not exist or if
/// the value is not the right type.
///
- const DagInit *getValueAsDag(StringRef FieldName) const;
+ DagInit *getValueAsDag(StringRef FieldName) const;
/// getValueAsCode - This method looks up the specified field and returns
/// its value as the string data in a CodeInit, throwing an exception if the
if (!V || !V->getValue())
continue;
- const DefInit *DI = dynamic_cast<const DefInit*>(V->getValue());
+ DefInit *DI = dynamic_cast<DefInit*>(V->getValue());
Record *Alias = DI->getDef();
DwarfRegNums[Reg] = DwarfRegNums[Alias];
}
// (add a, b, ...) Evaluate and union all arguments.
struct AddOp : public SetTheory::Operator {
- void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
+ void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
ST.evaluate(Expr->arg_begin(), Expr->arg_end(), Elts);
}
};
// (sub Add, Sub, ...) Set difference.
struct SubOp : public SetTheory::Operator {
- void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
+ void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
if (Expr->arg_size() < 2)
throw "Set difference needs at least two arguments: " +
Expr->getAsString();
// (and S1, S2) Set intersection.
struct AndOp : public SetTheory::Operator {
- void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
+ void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
if (Expr->arg_size() != 2)
throw "Set intersection requires two arguments: " + Expr->getAsString();
RecSet S1, S2;
// SetIntBinOp - Abstract base class for (Op S, N) operators.
struct SetIntBinOp : public SetTheory::Operator {
- virtual void apply2(SetTheory &ST, const DagInit *Expr,
+ virtual void apply2(SetTheory &ST, DagInit *Expr,
RecSet &Set, int64_t N,
RecSet &Elts) =0;
- void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
+ void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
if (Expr->arg_size() != 2)
throw "Operator requires (Op Set, Int) arguments: " + Expr->getAsString();
RecSet Set;
ST.evaluate(Expr->arg_begin()[0], Set);
- const IntInit *II = dynamic_cast<const IntInit*>(Expr->arg_begin()[1]);
+ IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[1]);
if (!II)
throw "Second argument must be an integer: " + Expr->getAsString();
apply2(ST, Expr, Set, II->getValue(), Elts);
// (shl S, N) Shift left, remove the first N elements.
struct ShlOp : public SetIntBinOp {
- void apply2(SetTheory &ST, const DagInit *Expr,
+ void apply2(SetTheory &ST, DagInit *Expr,
RecSet &Set, int64_t N,
RecSet &Elts) {
if (N < 0)
// (trunc S, N) Truncate after the first N elements.
struct TruncOp : public SetIntBinOp {
- void apply2(SetTheory &ST, const DagInit *Expr,
+ void apply2(SetTheory &ST, DagInit *Expr,
RecSet &Set, int64_t N,
RecSet &Elts) {
if (N < 0)
RotOp(bool Rev) : Reverse(Rev) {}
- void apply2(SetTheory &ST, const DagInit *Expr,
+ void apply2(SetTheory &ST, DagInit *Expr,
RecSet &Set, int64_t N,
RecSet &Elts) {
if (Reverse)
// (decimate S, N) Pick every N'th element of S.
struct DecimateOp : public SetIntBinOp {
- void apply2(SetTheory &ST, const DagInit *Expr,
+ void apply2(SetTheory &ST, DagInit *Expr,
RecSet &Set, int64_t N,
RecSet &Elts) {
if (N <= 0)
// (sequence "Format", From, To) Generate a sequence of records by name.
struct SequenceOp : public SetTheory::Operator {
- void apply(SetTheory &ST, const DagInit *Expr, RecSet &Elts) {
+ void apply(SetTheory &ST, DagInit *Expr, RecSet &Elts) {
if (Expr->arg_size() != 3)
throw "Bad args to (sequence \"Format\", From, To): " +
Expr->getAsString();
std::string Format;
- if (const StringInit *SI =
- dynamic_cast<const StringInit*>(Expr->arg_begin()[0]))
+ if (StringInit *SI = dynamic_cast<StringInit*>(Expr->arg_begin()[0]))
Format = SI->getValue();
else
throw "Format must be a string: " + Expr->getAsString();
int64_t From, To;
- if (const IntInit *II = dynamic_cast<const IntInit*>(Expr->arg_begin()[1]))
+ if (IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[1]))
From = II->getValue();
else
throw "From must be an integer: " + Expr->getAsString();
if (From < 0 || From >= (1 << 30))
throw "From out of range";
- if (const IntInit *II = dynamic_cast<const IntInit*>(Expr->arg_begin()[2]))
+ if (IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[2]))
To = II->getValue();
else
throw "From must be an integer: " + Expr->getAsString();
throw "To out of range";
RecordKeeper &Records =
- dynamic_cast<const DefInit&>(*Expr->getOperator()).getDef()->getRecords();
+ dynamic_cast<DefInit&>(*Expr->getOperator()).getDef()->getRecords();
int Step = From <= To ? 1 : -1;
for (To += Step; From != To; From += Step) {
addExpander(ClassName, new FieldExpander(FieldName));
}
-void SetTheory::evaluate(const Init *Expr, RecSet &Elts) {
+void SetTheory::evaluate(Init *Expr, RecSet &Elts) {
// A def in a list can be a just an element, or it may expand.
- if (const DefInit *Def = dynamic_cast<const DefInit*>(Expr)) {
+ if (DefInit *Def = dynamic_cast<DefInit*>(Expr)) {
if (const RecVec *Result = expand(Def->getDef()))
return Elts.insert(Result->begin(), Result->end());
Elts.insert(Def->getDef());
}
// Lists simply expand.
- if (const ListInit *LI = dynamic_cast<const ListInit*>(Expr))
+ if (ListInit *LI = dynamic_cast<ListInit*>(Expr))
return evaluate(LI->begin(), LI->end(), Elts);
// Anything else must be a DAG.
- const DagInit *DagExpr = dynamic_cast<const DagInit*>(Expr);
+ DagInit *DagExpr = dynamic_cast<DagInit*>(Expr);
if (!DagExpr)
throw "Invalid set element: " + Expr->getAsString();
- const DefInit *OpInit = dynamic_cast<const DefInit*>(DagExpr->getOperator());
+ DefInit *OpInit = dynamic_cast<DefInit*>(DagExpr->getOperator());
if (!OpInit)
throw "Bad set expression: " + Expr->getAsString();
Operator *Op = Operators.lookup(OpInit->getDef()->getName());
namespace llvm {
class DagInit;
-class Init;
+struct Init;
class Record;
class RecordKeeper;
/// apply - Apply this operator to Expr's arguments and insert the result
/// in Elts.
- virtual void apply(SetTheory&, const DagInit *Expr, RecSet &Elts) =0;
+ virtual void apply(SetTheory&, DagInit *Expr, RecSet &Elts) =0;
};
/// Expander - A callback function that can transform a Record representing a
void addOperator(StringRef Name, Operator*);
/// evaluate - Evaluate Expr and append the resulting set to Elts.
- void evaluate(const Init *Expr, RecSet &Elts);
+ void evaluate(Init *Expr, RecSet &Elts);
/// evaluate - Evaluate a sequence of Inits and append to Elts.
template<typename Iter>
struct SubClassReference {
SMLoc RefLoc;
Record *Rec;
- std::vector<const Init*> TemplateArgs;
+ std::vector<Init*> TemplateArgs;
SubClassReference() : Rec(0) {}
bool isInvalid() const { return Rec == 0; }
struct SubMultiClassReference {
SMLoc RefLoc;
MultiClass *MC;
- std::vector<const Init*> TemplateArgs;
+ std::vector<Init*> TemplateArgs;
SubMultiClassReference() : MC(0) {}
bool isInvalid() const { return MC == 0; }
MC->dump();
errs() << "Template args:\n";
- for (std::vector<const Init *>::const_iterator i = TemplateArgs.begin(),
+ for (std::vector<Init *>::const_iterator i = TemplateArgs.begin(),
iend = TemplateArgs.end();
i != iend;
++i) {
/// SetValue -
/// Return true on error, false on success.
bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName,
- const std::vector<unsigned> &BitList, const Init *V) {
+ const std::vector<unsigned> &BitList, Init *V) {
if (!V) return false;
if (CurRec == 0) CurRec = &CurMultiClass->Rec;
// Do not allow assignments like 'X = X'. This will just cause infinite loops
// in the resolution machinery.
if (BitList.empty())
- if (const VarInit *VI = dynamic_cast<const VarInit*>(V))
+ if (VarInit *VI = dynamic_cast<VarInit*>(V))
if (VI->getName() == ValName)
return false;
// initializer.
//
if (!BitList.empty()) {
- const BitsInit *CurVal = dynamic_cast<const BitsInit*>(RV->getValue());
+ BitsInit *CurVal = dynamic_cast<BitsInit*>(RV->getValue());
if (CurVal == 0)
return Error(Loc, "Value '" + ValName + "' is not a bits type");
// Convert the incoming value to a bits type of the appropriate size...
- const Init *BI = V->convertInitializerTo(new BitsRecTy(BitList.size()));
+ Init *BI = V->convertInitializerTo(new BitsRecTy(BitList.size()));
if (BI == 0) {
V->convertInitializerTo(new BitsRecTy(BitList.size()));
return Error(Loc, "Initializer is not compatible with bit range");
}
// We should have a BitsInit type now.
- const BitsInit *BInit = dynamic_cast<const BitsInit*>(BI);
+ BitsInit *BInit = dynamic_cast<BitsInit*>(BI);
assert(BInit != 0);
- SmallVector<const Init *, 16> NewBits(CurVal->getNumBits());
+ BitsInit *NewVal = new BitsInit(CurVal->getNumBits());
// Loop over bits, assigning values as appropriate.
for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
unsigned Bit = BitList[i];
- if (NewBits[Bit])
+ if (NewVal->getBit(Bit))
return Error(Loc, "Cannot set bit #" + utostr(Bit) + " of value '" +
ValName + "' more than once");
- NewBits[Bit] = BInit->getBit(i);
+ NewVal->setBit(Bit, BInit->getBit(i));
}
for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
- if (NewBits[i] == 0)
- NewBits[i] = CurVal->getBit(i);
+ if (NewVal->getBit(i) == 0)
+ NewVal->setBit(i, CurVal->getBit(i));
- V = BitsInit::get(NewBits.begin(), NewBits.end());
+ V = NewVal;
}
if (RV->setValue(V))
/// IDValue ::= ID [multiclass template argument]
/// IDValue ::= ID [def name]
///
-const Init *TGParser::ParseIDValue(Record *CurRec) {
+Init *TGParser::ParseIDValue(Record *CurRec) {
assert(Lex.getCode() == tgtok::Id && "Expected ID in ParseIDValue");
std::string Name = Lex.getCurStrVal();
SMLoc Loc = Lex.getLoc();
/// ParseIDValue - This is just like ParseIDValue above, but it assumes the ID
/// has already been read.
-const Init *TGParser::ParseIDValue(Record *CurRec,
+Init *TGParser::ParseIDValue(Record *CurRec,
const std::string &Name, SMLoc NameLoc) {
if (CurRec) {
if (const RecordVal *RV = CurRec->getValue(Name))
- return VarInit::get(Name, RV->getType());
+ return new VarInit(Name, RV->getType());
std::string TemplateArgName = CurRec->getName()+":"+Name;
if (CurRec->isTemplateArg(TemplateArgName)) {
const RecordVal *RV = CurRec->getValue(TemplateArgName);
assert(RV && "Template arg doesn't exist??");
- return VarInit::get(TemplateArgName, RV->getType());
+ return new VarInit(TemplateArgName, RV->getType());
}
}
if (CurMultiClass->Rec.isTemplateArg(MCName)) {
const RecordVal *RV = CurMultiClass->Rec.getValue(MCName);
assert(RV && "Template arg doesn't exist??");
- return VarInit::get(MCName, RV->getType());
+ return new VarInit(MCName, RV->getType());
}
}
if (Record *D = Records.getDef(Name))
- return DefInit::get(D);
+ return new DefInit(D);
Error(NameLoc, "Variable not defined: '" + Name + "'");
return 0;
///
/// Operation ::= XOperator ['<' Type '>'] '(' Args ')'
///
-const Init *TGParser::ParseOperation(Record *CurRec) {
+Init *TGParser::ParseOperation(Record *CurRec) {
switch (Lex.getCode()) {
default:
TokError("unknown operation");
}
Lex.Lex(); // eat the '('
- const Init *LHS = ParseValue(CurRec);
+ Init *LHS = ParseValue(CurRec);
if (LHS == 0) return 0;
if (Code == UnOpInit::HEAD
|| Code == UnOpInit::TAIL
|| Code == UnOpInit::EMPTY) {
- const ListInit *LHSl = dynamic_cast<const ListInit*>(LHS);
- const StringInit *LHSs = dynamic_cast<const StringInit*>(LHS);
- const TypedInit *LHSt = dynamic_cast<const TypedInit*>(LHS);
+ ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
+ StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
+ TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS);
if (LHSl == 0 && LHSs == 0 && LHSt == 0) {
TokError("expected list or string type argument in unary operator");
return 0;
return 0;
}
if (LHSl) {
- const Init *Item = LHSl->getElement(0);
- const TypedInit *Itemt = dynamic_cast<const TypedInit*>(Item);
+ Init *Item = LHSl->getElement(0);
+ TypedInit *Itemt = dynamic_cast<TypedInit*>(Item);
if (Itemt == 0) {
TokError("untyped list element in unary operator");
return 0;
return 0;
}
Lex.Lex(); // eat the ')'
- return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec, CurMultiClass);
+ return (new UnOpInit(Code, LHS, Type))->Fold(CurRec, CurMultiClass);
}
case tgtok::XConcat:
}
Lex.Lex(); // eat the '('
- SmallVector<const Init*, 2> InitList;
+ SmallVector<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) {
- const Init *RHS = InitList.pop_back_val();
- RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))
+ Init *RHS = InitList.pop_back_val();
+ RHS = (new BinOpInit(Code, InitList.back(), RHS, Type))
->Fold(CurRec, CurMultiClass);
InitList.back() = RHS;
}
}
if (InitList.size() == 2)
- return (BinOpInit::get(Code, InitList[0], InitList[1], Type))
+ return (new BinOpInit(Code, InitList[0], InitList[1], Type))
->Fold(CurRec, CurMultiClass);
Error(OpLoc, "expected two operands to operator");
}
Lex.Lex(); // eat the '('
- const Init *LHS = ParseValue(CurRec);
+ Init *LHS = ParseValue(CurRec);
if (LHS == 0) return 0;
if (Lex.getCode() != tgtok::comma) {
}
Lex.Lex(); // eat the ','
- const Init *MHS = ParseValue(CurRec);
+ Init *MHS = ParseValue(CurRec);
if (MHS == 0) return 0;
if (Lex.getCode() != tgtok::comma) {
}
Lex.Lex(); // eat the ','
- const Init *RHS = ParseValue(CurRec);
+ 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.
- const TypedInit *MHSt = dynamic_cast<const TypedInit*>(MHS);
- const TypedInit *RHSt = dynamic_cast<const TypedInit*>(RHS);
+ TypedInit *MHSt = dynamic_cast<TypedInit*>(MHS);
+ TypedInit *RHSt = dynamic_cast<TypedInit*>(RHS);
RecTy *MHSTy = 0;
RecTy *RHSTy = 0;
if (MHSt == 0 && RHSt == 0) {
- const BitsInit *MHSbits = dynamic_cast<const BitsInit*>(MHS);
- const BitsInit *RHSbits = dynamic_cast<const BitsInit*>(RHS);
+ BitsInit *MHSbits = dynamic_cast<BitsInit*>(MHS);
+ BitsInit *RHSbits = dynamic_cast<BitsInit*>(RHS);
if (MHSbits && RHSbits &&
MHSbits->getNumBits() == RHSbits->getNumBits()) {
Type = new BitRecTy();
break;
} else {
- const BitInit *MHSbit = dynamic_cast<const BitInit*>(MHS);
- const BitInit *RHSbit = dynamic_cast<const BitInit*>(RHS);
+ BitInit *MHSbit = dynamic_cast<BitInit*>(MHS);
+ BitInit *RHSbit = dynamic_cast<BitInit*>(RHS);
if (MHSbit && RHSbit) {
Type = new BitRecTy();
break;
}
case tgtok::XForEach: {
- const TypedInit *MHSt = dynamic_cast<const TypedInit *>(MHS);
+ TypedInit *MHSt = dynamic_cast<TypedInit *>(MHS);
if (MHSt == 0) {
TokError("could not get type for !foreach");
return 0;
break;
}
case tgtok::XSubst: {
- const TypedInit *RHSt = dynamic_cast<const TypedInit *>(RHS);
+ TypedInit *RHSt = dynamic_cast<TypedInit *>(RHS);
if (RHSt == 0) {
TokError("could not get type for !subst");
return 0;
break;
}
}
- return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec,
+ return (new TernOpInit(Code, LHS, MHS, RHS, Type))->Fold(CurRec,
CurMultiClass);
}
}
/// SimpleValue ::= SRLTOK '(' Value ',' Value ')'
/// SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')'
///
-const Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
- const Init *R = 0;
+Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
+ Init *R = 0;
switch (Lex.getCode()) {
default: TokError("Unknown token when parsing a value"); break;
- case tgtok::IntVal: R = IntInit::get(Lex.getCurIntVal()); Lex.Lex(); break;
+ case tgtok::IntVal: R = new IntInit(Lex.getCurIntVal()); Lex.Lex(); break;
case tgtok::StrVal: {
std::string Val = Lex.getCurStrVal();
Lex.Lex();
Lex.Lex();
}
- R = StringInit::get(Val);
+ R = new StringInit(Val);
break;
}
case tgtok::CodeFragment:
- R = CodeInit::get(Lex.getCurStrVal());
+ R = new CodeInit(Lex.getCurStrVal());
Lex.Lex();
break;
case tgtok::question:
- R = UnsetInit::get();
+ R = new UnsetInit();
Lex.Lex();
break;
case tgtok::Id: {
return 0;
}
- std::vector<const Init*> ValueList = ParseValueList(CurRec, Class);
+ std::vector<Init*> ValueList = ParseValueList(CurRec, Class);
if (ValueList.empty()) return 0;
if (Lex.getCode() != tgtok::greater) {
Records.addDef(NewRec);
// The result of the expression is a reference to the new record.
- return DefInit::get(NewRec);
+ return new DefInit(NewRec);
}
case tgtok::l_brace: { // Value ::= '{' ValueList '}'
SMLoc BraceLoc = Lex.getLoc();
Lex.Lex(); // eat the '{'
- std::vector<const Init*> Vals;
+ std::vector<Init*> Vals;
if (Lex.getCode() != tgtok::r_brace) {
Vals = ParseValueList(CurRec);
}
Lex.Lex(); // eat the '}'
- SmallVector<const Init *, 16> NewBits(Vals.size());
-
+ BitsInit *Result = new BitsInit(Vals.size());
for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
- const Init *Bit = Vals[i]->convertInitializerTo(new BitRecTy());
+ Init *Bit = Vals[i]->convertInitializerTo(new BitRecTy());
if (Bit == 0) {
Error(BraceLoc, "Element #" + utostr(i) + " (" + Vals[i]->getAsString()+
") is not convertable to a bit");
return 0;
}
- NewBits[Vals.size()-i-1] = Bit;
+ Result->setBit(Vals.size()-i-1, Bit);
}
- return BitsInit::get(NewBits.begin(), NewBits.end());
+ return Result;
}
case tgtok::l_square: { // Value ::= '[' ValueList ']'
Lex.Lex(); // eat the '['
- std::vector<const Init*> Vals;
+ std::vector<Init*> Vals;
RecTy *DeducedEltTy = 0;
ListRecTy *GivenListTy = 0;
// Check elements
RecTy *EltTy = 0;
- for (std::vector<const Init *>::iterator i = Vals.begin(), ie = Vals.end();
+ for (std::vector<Init *>::iterator i = Vals.begin(), ie = Vals.end();
i != ie;
++i) {
- const TypedInit *TArg = dynamic_cast<const TypedInit*>(*i);
+ TypedInit *TArg = dynamic_cast<TypedInit*>(*i);
if (TArg == 0) {
TokError("Untyped list element");
return 0;
DeducedEltTy = EltTy;
}
- return ListInit::get(Vals, DeducedEltTy);
+ return new ListInit(Vals, DeducedEltTy);
}
case tgtok::l_paren: { // Value ::= '(' IDValue DagArgList ')'
Lex.Lex(); // eat the '('
return 0;
}
- const Init *Operator = ParseValue(CurRec);
+ 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<const Init*, std::string> > DagArgs;
+ std::vector<std::pair<llvm::Init*, std::string> > DagArgs;
if (Lex.getCode() != tgtok::r_paren) {
DagArgs = ParseDagArgList(CurRec);
if (DagArgs.empty()) return 0;
}
Lex.Lex(); // eat the ')'
- return DagInit::get(Operator, OperatorName, DagArgs);
+ return new DagInit(Operator, OperatorName, DagArgs);
}
case tgtok::XHead:
/// ValueSuffix ::= '[' BitList ']'
/// ValueSuffix ::= '.' ID
///
-const Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) {
- const Init *Result = ParseSimpleValue(CurRec, ItemType);
+Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType) {
+ Init *Result = ParseSimpleValue(CurRec, ItemType);
if (Result == 0) return 0;
// Parse the suffixes now if present.
Result->getAsString() + "'");
return 0;
}
- Result = FieldInit::get(Result, Lex.getCurStrVal());
+ Result = new FieldInit(Result, Lex.getCurStrVal());
Lex.Lex(); // eat field name
break;
}
///
/// ParseDagArgList ::= Value (':' VARNAME)?
/// ParseDagArgList ::= ParseDagArgList ',' Value (':' VARNAME)?
-std::vector<std::pair<const Init*, std::string> >
+std::vector<std::pair<llvm::Init*, std::string> >
TGParser::ParseDagArgList(Record *CurRec) {
- std::vector<std::pair<const Init*, std::string> > Result;
+ std::vector<std::pair<llvm::Init*, std::string> > Result;
while (1) {
- const Init *Val = ParseValue(CurRec);
- if (Val == 0) return std::vector<std::pair<const Init*, std::string> >();
+ Init *Val = ParseValue(CurRec);
+ if (Val == 0) return std::vector<std::pair<llvm::Init*, std::string> >();
// If the variable name is present, add it.
std::string VarName;
if (Lex.getCode() == tgtok::colon) {
if (Lex.Lex() != tgtok::VarName) { // eat the ':'
TokError("expected variable name in dag literal");
- return std::vector<std::pair<const Init*, std::string> >();
+ return std::vector<std::pair<llvm::Init*, std::string> >();
}
VarName = Lex.getCurStrVal();
Lex.Lex(); // eat the VarName.
///
/// ValueList ::= Value (',' Value)
///
-std::vector<const Init*> TGParser::ParseValueList(Record *CurRec,
- Record *ArgsRec,
- RecTy *EltTy) {
- std::vector<const Init*> Result;
+std::vector<Init*> TGParser::ParseValueList(Record *CurRec, Record *ArgsRec,
+ RecTy *EltTy) {
+ std::vector<Init*> Result;
RecTy *ItemType = EltTy;
unsigned int ArgN = 0;
if (ArgsRec != 0 && EltTy == 0) {
++ArgN;
}
Result.push_back(ParseValue(CurRec, ItemType));
- if (Result.back() == 0) return std::vector<const Init*>();
+ if (Result.back() == 0) return std::vector<Init*>();
while (Lex.getCode() == tgtok::comma) {
Lex.Lex(); // Eat the comma
const std::vector<std::string> &TArgs = ArgsRec->getTemplateArgs();
if (ArgN >= TArgs.size()) {
TokError("too many template arguments");
- return std::vector<const Init*>();
+ return std::vector<Init*>();
}
const RecordVal *RV = ArgsRec->getValue(TArgs[ArgN]);
assert(RV && "Template argument record not found??");
++ArgN;
}
Result.push_back(ParseValue(CurRec, ItemType));
- if (Result.back() == 0) return std::vector<const Init*>();
+ if (Result.back() == 0) return std::vector<Init*>();
}
return Result;
if (Lex.getCode() == tgtok::equal) {
Lex.Lex();
SMLoc ValLoc = Lex.getLoc();
- const Init *Val = ParseValue(CurRec, Type);
+ Init *Val = ParseValue(CurRec, Type);
if (Val == 0 ||
SetValue(CurRec, ValLoc, DeclName, std::vector<unsigned>(), Val))
return "";
RecTy *Type = Field->getType();
- const Init *Val = ParseValue(CurRec, Type);
+ Init *Val = ParseValue(CurRec, Type);
if (Val == 0) return true;
if (Lex.getCode() != tgtok::semi)
}
Lex.Lex(); // eat the '='.
- const Init *Val = ParseValue(0);
+ Init *Val = ParseValue(0);
if (Val == 0) return std::vector<LetRecord>();
// Now that we have everything, add the record.
// template parameters.
MultiClass *MC = MultiClasses[Ref.Rec->getName()];
assert(MC && "Didn't lookup multiclass correctly?");
- std::vector<const Init*> &TemplateVals = Ref.TemplateArgs;
+ std::vector<Init*> &TemplateVals = Ref.TemplateArgs;
// Verify that the correct number of template arguments were specified.
const std::vector<std::string> &TArgs = MC->Rec.getTemplateArgs();
class RecordVal;
class RecordKeeper;
struct RecTy;
- class Init;
+ struct Init;
struct MultiClass;
struct SubClassReference;
struct SubMultiClassReference;
struct LetRecord {
std::string Name;
std::vector<unsigned> Bits;
- const Init *Value;
+ Init *Value;
SMLoc Loc;
- LetRecord(const std::string &N, const std::vector<unsigned> &B,
- const Init *V, SMLoc L)
+ LetRecord(const std::string &N, const std::vector<unsigned> &B, Init *V,
+ SMLoc L)
: Name(N), Bits(B), Value(V), Loc(L) {
}
};
private: // Semantic analysis methods.
bool AddValue(Record *TheRec, SMLoc Loc, const RecordVal &RV);
bool SetValue(Record *TheRec, SMLoc Loc, const std::string &ValName,
- const std::vector<unsigned> &BitList, const Init *V);
+ const std::vector<unsigned> &BitList, Init *V);
bool AddSubClass(Record *Rec, SubClassReference &SubClass);
bool AddSubMultiClass(MultiClass *CurMC,
SubMultiClassReference &SubMultiClass);
SubClassReference ParseSubClassReference(Record *CurRec, bool isDefm);
SubMultiClassReference ParseSubMultiClassReference(MultiClass *CurMC);
- const Init *ParseIDValue(Record *CurRec);
- const Init *ParseIDValue(Record *CurRec, const std::string &Name,
- SMLoc NameLoc);
- const Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = 0);
- const Init *ParseValue(Record *CurRec, RecTy *ItemType = 0);
- std::vector<const Init*> ParseValueList(Record *CurRec, Record *ArgsRec = 0,
- RecTy *EltTy = 0);
- std::vector<std::pair<const Init*, std::string> > ParseDagArgList(Record *);
+ Init *ParseIDValue(Record *CurRec);
+ Init *ParseIDValue(Record *CurRec, const std::string &Name, SMLoc NameLoc);
+ Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = 0);
+ Init *ParseValue(Record *CurRec, RecTy *ItemType = 0);
+ std::vector<Init*> ParseValueList(Record *CurRec, Record *ArgsRec = 0, RecTy *EltTy = 0);
+ std::vector<std::pair<llvm::Init*, std::string> > ParseDagArgList(Record *);
bool ParseOptionalRangeList(std::vector<unsigned> &Ranges);
bool ParseOptionalBitList(std::vector<unsigned> &Ranges);
std::vector<unsigned> ParseRangeList();
bool ParseRangePiece(std::vector<unsigned> &Ranges);
RecTy *ParseType();
- const Init *ParseOperation(Record *CurRec);
+ Init *ParseOperation(Record *CurRec);
RecTy *ParseOperatorType();
std::string ParseObjectName();
Record *ParseClassID();
if (error_code ec = MemoryBuffer::getFileOrSTDIN(InputFilename.c_str(), File)) {
errs() << "Could not open input file '" << InputFilename << "': "
<< ec.message() <<"\n";
- Init::ReleaseMemory();
return 1;
}
MemoryBuffer *F = File.take();
TGParser Parser(SrcMgr, Records);
- if (Parser.ParseFile()) {
- Init::ReleaseMemory();
+ if (Parser.ParseFile())
return 1;
- }
std::string Error;
tool_output_file Out(OutputFilename.c_str(), Error);
if (!Error.empty()) {
errs() << argv[0] << ": error opening " << OutputFilename
<< ":" << Error << "\n";
- Init::ReleaseMemory();
return 1;
}
if (!DependFilename.empty()) {
if (OutputFilename == "-") {
errs() << argv[0] << ": the option -d must be used together with -o\n";
- Init::ReleaseMemory();
return 1;
}
tool_output_file DepOut(DependFilename.c_str(), Error);
if (!Error.empty()) {
errs() << argv[0] << ": error opening " << DependFilename
<< ":" << Error << "\n";
- Init::ReleaseMemory();
return 1;
}
DepOut.os() << DependFilename << ":";
}
default:
assert(1 && "Invalid Action");
- Init::ReleaseMemory();
return 1;
}
// Declare success.
Out.keep();
-
- Init::ReleaseMemory();
return 0;
} catch (const TGError &Error) {
errs() << argv[0] << ": Unknown unexpected exception occurred.\n";
}
- Init::ReleaseMemory();
-
return 1;
}
/// @param init - A reference to the BitsInit to be decoded.
/// @return - The field, with the first bit in the BitsInit as the lowest
/// order bit.
-static uint8_t byteFromBitsInit(const BitsInit &init) {
+static uint8_t byteFromBitsInit(BitsInit &init) {
int width = init.getNumBits();
assert(width <= 8 && "Field is too large for uint8_t!");
uint8_t ret = 0;
for (index = 0; index < width; index++) {
- if (static_cast<const BitInit*>(init.getBit(index))->getValue())
+ if (static_cast<BitInit*>(init.getBit(index))->getValue())
ret |= mask;
mask <<= 1;
/// @param name - The name of the field in the record.
/// @return - The field, as translated by byteFromBitsInit().
static uint8_t byteFromRec(const Record* rec, const std::string &name) {
- const BitsInit* bits = rec->getValueAsBitsInit(name);
+ BitsInit* bits = rec->getValueAsBitsInit(name);
return byteFromBitsInit(*bits);
}
projects / oota-llvm.git / commitdiff