maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

tblgen: Mechanically move dynamic_cast<> to dyn_cast<>. 

Some of these dyn_cast<>'s would be better phrased as isa<> or cast<>.
That will happen in a future patch.

There are also two dyn_cast_or_null<>'s slipped in instead of
dyn_cast<>'s, since they were causing crashes with just dyn_cast<>.

llvm-svn: 165646
This commit is contained in:
Sean Silva 2012-10-10 20:24:43 +00:00
parent be46d12ed5
commit fb509ed156
15 changed files with 192 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
llvm/lib/TableGen/Record.cpp
View File

@ -200,7 +200,7 @@ Init *IntRecTy::convertValue(BitInit *BI) {
Init *IntRecTy::convertValue(BitsInit *BI) { Init *IntRecTy::convertValue(BitsInit *BI) {
int64_t Result = 0; int64_t Result = 0;
for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) { if (BitInit *Bit = dyn_cast<BitInit>(BI->getBit(i))) {
Result |= Bit->getValue() << i; Result |= Bit->getValue() << i;
} else { } else {
return 0; return 0;
@ -615,7 +615,7 @@ ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const {
Record *ListInit::getElementAsRecord(unsigned i) const { Record *ListInit::getElementAsRecord(unsigned i) const {
assert(i < Values.size() && "List element index out of range!"); assert(i < Values.size() && "List element index out of range!");
DefInit *DI = dynamic_cast<DefInit*>(Values[i]); DefInit *DI = dyn_cast<DefInit>(Values[i]);
if (DI == 0) throw "Expected record in list!"; if (DI == 0) throw "Expected record in list!";
return DI->getDef(); return DI->getDef();
} }
@ -650,7 +650,7 @@ Init *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV,
// If the element is set to some value, or if we are resolving a reference // 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 // to a specific variable and that variable is explicitly unset, then
// replace the VarListElementInit with it. // replace the VarListElementInit with it.
if (IRV || !dynamic_cast<UnsetInit*>(E)) if (IRV || !dyn_cast<UnsetInit>(E))
return E; return E;
return 0; return 0;
} }
@ -667,13 +667,13 @@ std::string ListInit::getAsString() const {
Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV, Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV,
unsigned Elt) const { unsigned Elt) const {
Init *Resolved = resolveReferences(R, IRV); Init *Resolved = resolveReferences(R, IRV);
OpInit *OResolved = dynamic_cast<OpInit *>(Resolved); OpInit *OResolved = dyn_cast<OpInit>(Resolved);
if (OResolved) { if (OResolved) {
Resolved = OResolved->Fold(&R, 0); Resolved = OResolved->Fold(&R, 0);
} }
if (Resolved != this) { if (Resolved != this) {
TypedInit *Typed = dynamic_cast<TypedInit *>(Resolved); TypedInit *Typed = dyn_cast<TypedInit>(Resolved);
assert(Typed && "Expected typed init for list reference"); assert(Typed && "Expected typed init for list reference");
if (Typed) { if (Typed) {
Init *New = Typed->resolveListElementReference(R, IRV, Elt); Init *New = Typed->resolveListElementReference(R, IRV, Elt);
@ -709,22 +709,22 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
switch (getOpcode()) { switch (getOpcode()) {
case CAST: { case CAST: {
if (getType()->getAsString() == "string") { if (getType()->getAsString() == "string") {
StringInit *LHSs = dynamic_cast<StringInit*>(LHS); StringInit *LHSs = dyn_cast<StringInit>(LHS);
if (LHSs) { if (LHSs) {
return LHSs; return LHSs;
} }
DefInit *LHSd = dynamic_cast<DefInit*>(LHS); DefInit *LHSd = dyn_cast<DefInit>(LHS);
if (LHSd) { if (LHSd) {
return StringInit::get(LHSd->getDef()->getName()); return StringInit::get(LHSd->getDef()->getName());
} }
IntInit *LHSi = dynamic_cast<IntInit*>(LHS); IntInit *LHSi = dyn_cast<IntInit>(LHS);
if (LHSi) { if (LHSi) {
return StringInit::get(LHSi->getAsString()); return StringInit::get(LHSi->getAsString());
} }
} else { } else {
StringInit *LHSs = dynamic_cast<StringInit*>(LHS); StringInit *LHSs = dyn_cast<StringInit>(LHS);
if (LHSs) { if (LHSs) {
std::string Name = LHSs->getValue(); std::string Name = LHSs->getValue();
@ -773,7 +773,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
break; break;
} }
case HEAD: { case HEAD: {
ListInit *LHSl = dynamic_cast<ListInit*>(LHS); ListInit *LHSl = dyn_cast<ListInit>(LHS);
if (LHSl) { if (LHSl) {
if (LHSl->getSize() == 0) { if (LHSl->getSize() == 0) {
assert(0 && "Empty list in car"); assert(0 && "Empty list in car");
@ -784,7 +784,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
break; break;
} }
case TAIL: { case TAIL: {
ListInit *LHSl = dynamic_cast<ListInit*>(LHS); ListInit *LHSl = dyn_cast<ListInit>(LHS);
if (LHSl) { if (LHSl) {
if (LHSl->getSize() == 0) { if (LHSl->getSize() == 0) {
assert(0 && "Empty list in cdr"); assert(0 && "Empty list in cdr");
@ -802,7 +802,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
break; break;
} }
case EMPTY: { case EMPTY: {
ListInit *LHSl = dynamic_cast<ListInit*>(LHS); ListInit *LHSl = dyn_cast<ListInit>(LHS);
if (LHSl) { if (LHSl) {
if (LHSl->getSize() == 0) { if (LHSl->getSize() == 0) {
return IntInit::get(1); return IntInit::get(1);
@ -810,7 +810,7 @@ Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
return IntInit::get(0); return IntInit::get(0);
} }
} }
StringInit *LHSs = dynamic_cast<StringInit*>(LHS); StringInit *LHSs = dyn_cast<StringInit>(LHS);
if (LHSs) { if (LHSs) {
if (LHSs->getValue().empty()) { if (LHSs->getValue().empty()) {
return IntInit::get(1); return IntInit::get(1);
@ -865,11 +865,11 @@ BinOpInit *BinOpInit::get(BinaryOp opc, Init *lhs,
Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
switch (getOpcode()) { switch (getOpcode()) {
case CONCAT: { case CONCAT: {
DagInit *LHSs = dynamic_cast<DagInit*>(LHS); DagInit *LHSs = dyn_cast<DagInit>(LHS);
DagInit *RHSs = dynamic_cast<DagInit*>(RHS); DagInit *RHSs = dyn_cast<DagInit>(RHS);
if (LHSs && RHSs) { if (LHSs && RHSs) {
DefInit *LOp = dynamic_cast<DefInit*>(LHSs->getOperator()); DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator());
DefInit *ROp = dynamic_cast<DefInit*>(RHSs->getOperator()); DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator());
if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef()) if (LOp == 0 || ROp == 0 || LOp->getDef() != ROp->getDef())
throw "Concated Dag operators do not match!"; throw "Concated Dag operators do not match!";
std::vector<Init*> Args; std::vector<Init*> Args;
@ -887,8 +887,8 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
break; break;
} }
case STRCONCAT: { case STRCONCAT: {
StringInit *LHSs = dynamic_cast<StringInit*>(LHS); StringInit *LHSs = dyn_cast<StringInit>(LHS);
StringInit *RHSs = dynamic_cast<StringInit*>(RHS); StringInit *RHSs = dyn_cast<StringInit>(RHS);
if (LHSs && RHSs) if (LHSs && RHSs)
return StringInit::get(LHSs->getValue() + RHSs->getValue()); return StringInit::get(LHSs->getValue() + RHSs->getValue());
break; break;
@ -897,15 +897,15 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
// try to fold eq comparison for 'bit' and 'int', otherwise fallback // try to fold eq comparison for 'bit' and 'int', otherwise fallback
// to string objects. // to string objects.
IntInit *L = IntInit *L =
dynamic_cast<IntInit*>(LHS->convertInitializerTo(IntRecTy::get())); dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get()));
IntInit *R = IntInit *R =
dynamic_cast<IntInit*>(RHS->convertInitializerTo(IntRecTy::get())); dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get()));
if (L && R) if (L && R)
return IntInit::get(L->getValue() == R->getValue()); return IntInit::get(L->getValue() == R->getValue());
StringInit *LHSs = dynamic_cast<StringInit*>(LHS); StringInit *LHSs = dyn_cast<StringInit>(LHS);
StringInit *RHSs = dynamic_cast<StringInit*>(RHS); StringInit *RHSs = dyn_cast<StringInit>(RHS);
// Make sure we've resolved // Make sure we've resolved
if (LHSs && RHSs) if (LHSs && RHSs)
@ -916,8 +916,8 @@ Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
case SHL: case SHL:
case SRA: case SRA:
case SRL: { case SRL: {
IntInit *LHSi = dynamic_cast<IntInit*>(LHS); IntInit *LHSi = dyn_cast<IntInit>(LHS);
IntInit *RHSi = dynamic_cast<IntInit*>(RHS); IntInit *RHSi = dyn_cast<IntInit>(RHS);
if (LHSi && RHSi) { if (LHSi && RHSi) {
int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue(); int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue();
int64_t Result; int64_t Result;
@ -990,7 +990,7 @@ static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
MultiClass *CurMultiClass) { MultiClass *CurMultiClass) {
std::vector<Init *> NewOperands; std::vector<Init *> NewOperands;
TypedInit *TArg = dynamic_cast<TypedInit*>(Arg); TypedInit *TArg = dyn_cast<TypedInit>(Arg);
// If this is a dag, recurse // If this is a dag, recurse
if (TArg && TArg->getType()->getAsString() == "dag") { if (TArg && TArg->getType()->getAsString() == "dag") {
@ -1004,7 +1004,7 @@ static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
} }
for (int i = 0; i < RHSo->getNumOperands(); ++i) { for (int i = 0; i < RHSo->getNumOperands(); ++i) {
OpInit *RHSoo = dynamic_cast<OpInit*>(RHSo->getOperand(i)); OpInit *RHSoo = dyn_cast<OpInit>(RHSo->getOperand(i));
if (RHSoo) { if (RHSoo) {
Init *Result = EvaluateOperation(RHSoo, LHS, Arg, Init *Result = EvaluateOperation(RHSoo, LHS, Arg,
@ -1032,16 +1032,16 @@ static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type, static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
Record *CurRec, MultiClass *CurMultiClass) { Record *CurRec, MultiClass *CurMultiClass) {
DagInit *MHSd = dynamic_cast<DagInit*>(MHS); DagInit *MHSd = dyn_cast<DagInit>(MHS);
ListInit *MHSl = dynamic_cast<ListInit*>(MHS); ListInit *MHSl = dyn_cast<ListInit>(MHS);
OpInit *RHSo = dynamic_cast<OpInit*>(RHS); OpInit *RHSo = dyn_cast<OpInit>(RHS);
if (!RHSo) { if (!RHSo) {
throw TGError(CurRec->getLoc(), "!foreach requires an operator\n"); throw TGError(CurRec->getLoc(), "!foreach requires an operator\n");
} }
TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS); TypedInit *LHSt = dyn_cast<TypedInit>(LHS);
if (!LHSt) { if (!LHSt) {
throw TGError(CurRec->getLoc(), "!foreach requires typed variable\n"); throw TGError(CurRec->getLoc(), "!foreach requires typed variable\n");
@ -1110,17 +1110,17 @@ static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const { Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
switch (getOpcode()) { switch (getOpcode()) {
case SUBST: { case SUBST: {
DefInit *LHSd = dynamic_cast<DefInit*>(LHS); DefInit *LHSd = dyn_cast<DefInit>(LHS);
VarInit *LHSv = dynamic_cast<VarInit*>(LHS); VarInit *LHSv = dyn_cast<VarInit>(LHS);
StringInit *LHSs = dynamic_cast<StringInit*>(LHS); StringInit *LHSs = dyn_cast<StringInit>(LHS);
DefInit *MHSd = dynamic_cast<DefInit*>(MHS); DefInit *MHSd = dyn_cast<DefInit>(MHS);
VarInit *MHSv = dynamic_cast<VarInit*>(MHS); VarInit *MHSv = dyn_cast<VarInit>(MHS);
StringInit *MHSs = dynamic_cast<StringInit*>(MHS); StringInit *MHSs = dyn_cast<StringInit>(MHS);
DefInit *RHSd = dynamic_cast<DefInit*>(RHS); DefInit *RHSd = dyn_cast<DefInit>(RHS);
VarInit *RHSv = dynamic_cast<VarInit*>(RHS); VarInit *RHSv = dyn_cast<VarInit>(RHS);
StringInit *RHSs = dynamic_cast<StringInit*>(RHS); StringInit *RHSs = dyn_cast<StringInit>(RHS);
if ((LHSd && MHSd && RHSd) if ((LHSd && MHSd && RHSd)
|| (LHSv && MHSv && RHSv) || (LHSv && MHSv && RHSv)
@ -1168,9 +1168,9 @@ Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
} }
case IF: { case IF: {
IntInit *LHSi = dynamic_cast<IntInit*>(LHS); IntInit *LHSi = dyn_cast<IntInit>(LHS);
if (Init *I = LHS->convertInitializerTo(IntRecTy::get())) if (Init *I = LHS->convertInitializerTo(IntRecTy::get()))
LHSi = dynamic_cast<IntInit*>(I); LHSi = dyn_cast<IntInit>(I);
if (LHSi) { if (LHSi) {
if (LHSi->getValue()) { if (LHSi->getValue()) {
return MHS; return MHS;
@ -1190,9 +1190,9 @@ Init *TernOpInit::resolveReferences(Record &R,
Init *lhs = LHS->resolveReferences(R, RV); Init *lhs = LHS->resolveReferences(R, RV);
if (Opc == IF && lhs != LHS) { if (Opc == IF && lhs != LHS) {
IntInit *Value = dynamic_cast<IntInit*>(lhs); IntInit *Value = dyn_cast<IntInit>(lhs);
if (Init *I = lhs->convertInitializerTo(IntRecTy::get())) if (Init *I = lhs->convertInitializerTo(IntRecTy::get()))
Value = dynamic_cast<IntInit*>(I); Value = dyn_cast<IntInit>(I);
if (Value != 0) { if (Value != 0) {
// Short-circuit // Short-circuit
if (Value->getValue()) { if (Value->getValue()) {
@ -1286,7 +1286,7 @@ VarInit *VarInit::get(Init *VN, RecTy *T) {
const std::string &VarInit::getName() const { const std::string &VarInit::getName() const {
StringInit *NameString = StringInit *NameString =
dynamic_cast<StringInit *>(getNameInit()); dyn_cast<StringInit>(getNameInit());
assert(NameString && "VarInit name is not a string!"); assert(NameString && "VarInit name is not a string!");
return NameString->getValue(); return NameString->getValue();
} }
@ -1305,9 +1305,9 @@ Init *VarInit::resolveListElementReference(Record &R,
RecordVal *RV = R.getValue(getNameInit()); RecordVal *RV = R.getValue(getNameInit());
assert(RV && "Reference to a non-existent variable?"); assert(RV && "Reference to a non-existent variable?");
ListInit *LI = dynamic_cast<ListInit*>(RV->getValue()); ListInit *LI = dyn_cast<ListInit>(RV->getValue());
if (!LI) { if (!LI) {
TypedInit *VI = dynamic_cast<TypedInit*>(RV->getValue()); TypedInit *VI = dyn_cast<TypedInit>(RV->getValue());
assert(VI && "Invalid list element!"); assert(VI && "Invalid list element!");
return VarListElementInit::get(VI, Elt); return VarListElementInit::get(VI, Elt);
} }
@ -1318,7 +1318,7 @@ Init *VarInit::resolveListElementReference(Record &R,
// If the element is set to some value, or if we are resolving a reference // 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 // to a specific variable and that variable is explicitly unset, then
// replace the VarListElementInit with it. // replace the VarListElementInit with it.
if (IRV || !dynamic_cast<UnsetInit*>(E)) if (IRV || !dyn_cast<UnsetInit>(E))
return E; return E;
return 0; return 0;
} }
@ -1335,7 +1335,7 @@ Init *VarInit::getFieldInit(Record &R, const RecordVal *RV,
const std::string &FieldName) const { const std::string &FieldName) const {
if (isa<RecordRecTy>(getType())) if (isa<RecordRecTy>(getType()))
if (const RecordVal *Val = R.getValue(VarName)) { if (const RecordVal *Val = R.getValue(VarName)) {
if (RV != Val && (RV || dynamic_cast<UnsetInit*>(Val->getValue()))) if (RV != Val && (RV || dyn_cast<UnsetInit>(Val->getValue())))
return 0; return 0;
Init *TheInit = Val->getValue(); Init *TheInit = Val->getValue();
assert(TheInit != this && "Infinite loop detected!"); assert(TheInit != this && "Infinite loop detected!");
@ -1354,7 +1354,7 @@ Init *VarInit::getFieldInit(Record &R, const RecordVal *RV,
/// ///
Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) const { Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) const {
if (RecordVal *Val = R.getValue(VarName)) if (RecordVal *Val = R.getValue(VarName))
if (RV == Val || (RV == 0 && !dynamic_cast<UnsetInit*>(Val->getValue()))) if (RV == Val || (RV == 0 && !dyn_cast<UnsetInit>(Val->getValue())))
return Val->getValue(); return Val->getValue();
return const_cast<VarInit *>(this); return const_cast<VarInit *>(this);
} }
@ -1422,7 +1422,7 @@ Init *VarListElementInit:: resolveListElementReference(Record &R,
Init *Result = TI->resolveListElementReference(R, RV, Element); Init *Result = TI->resolveListElementReference(R, RV, Element);
if (Result) { if (Result) {
TypedInit *TInit = dynamic_cast<TypedInit *>(Result); TypedInit *TInit = dyn_cast<TypedInit>(Result);
if (TInit) { if (TInit) {
Init *Result2 = TInit->resolveListElementReference(R, RV, Elt); Init *Result2 = TInit->resolveListElementReference(R, RV, Elt);
if (Result2) return Result2; if (Result2) return Result2;
@ -1475,14 +1475,14 @@ Init *FieldInit::getBit(unsigned Bit) const {
Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV, Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV,
unsigned Elt) const { unsigned Elt) const {
if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName)) if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName))
if (ListInit *LI = dynamic_cast<ListInit*>(ListVal)) { if (ListInit *LI = dyn_cast<ListInit>(ListVal)) {
if (Elt >= LI->getSize()) return 0; if (Elt >= LI->getSize()) return 0;
Init *E = LI->getElement(Elt); Init *E = LI->getElement(Elt);
// If the element is set to some value, or if we are resolving a // If the element is set to some value, or if we are resolving a
// reference to a specific variable and that variable is explicitly // reference to a specific variable and that variable is explicitly
// unset, then replace the VarListElementInit with it. // unset, then replace the VarListElementInit with it.
if (RV || !dynamic_cast<UnsetInit*>(E)) if (RV || !dyn_cast<UnsetInit>(E))
return E; return E;
} }
return 0; return 0;
@ -1611,7 +1611,7 @@ RecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P)
} }
const std::string &RecordVal::getName() const { const std::string &RecordVal::getName() const {
StringInit *NameString = dynamic_cast<StringInit *>(Name); StringInit *NameString = dyn_cast<StringInit>(Name);
assert(NameString && "RecordVal name is not a string!"); assert(NameString && "RecordVal name is not a string!");
return NameString->getValue(); return NameString->getValue();
} }
@ -1641,7 +1641,7 @@ void Record::init() {
void Record::checkName() { void Record::checkName() {
// Ensure the record name has string type. // Ensure the record name has string type.
const TypedInit *TypedName = dynamic_cast<const TypedInit *>(Name); const TypedInit *TypedName = dyn_cast<const TypedInit>(Name);
assert(TypedName && "Record name is not typed!"); assert(TypedName && "Record name is not typed!");
RecTy *Type = TypedName->getType(); RecTy *Type = TypedName->getType();
if (!isa<StringRecTy>(Type)) if (!isa<StringRecTy>(Type))
@ -1656,7 +1656,7 @@ DefInit *Record::getDefInit() {
const std::string &Record::getName() const { const std::string &Record::getName() const {
const StringInit *NameString = const StringInit *NameString =
dynamic_cast<const StringInit *>(Name); dyn_cast<const StringInit>(Name);
assert(NameString && "Record name is not a string!"); assert(NameString && "Record name is not a string!");
return NameString->getValue(); return NameString->getValue();
} }
@ -1773,7 +1773,7 @@ std::string Record::getValueAsString(StringRef FieldName) const {
throw "Record `" + getName() + "' does not have a field named `" + throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n"; FieldName.str() + "'!\n";
if (StringInit *SI = dynamic_cast<StringInit*>(R->getValue())) if (StringInit *SI = dyn_cast<StringInit>(R->getValue()))
return SI->getValue(); return SI->getValue();
throw "Record `" + getName() + "', field `" + FieldName.str() + throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a string initializer!"; "' does not have a string initializer!";
@ -1789,7 +1789,7 @@ BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
throw "Record `" + getName() + "' does not have a field named `" + throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n"; FieldName.str() + "'!\n";
if (BitsInit *BI = dynamic_cast<BitsInit*>(R->getValue())) if (BitsInit *BI = dyn_cast<BitsInit>(R->getValue()))
return BI; return BI;
throw "Record `" + getName() + "', field `" + FieldName.str() + throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a BitsInit initializer!"; "' does not have a BitsInit initializer!";
@ -1805,7 +1805,7 @@ ListInit *Record::getValueAsListInit(StringRef FieldName) const {
throw "Record `" + getName() + "' does not have a field named `" + throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n"; FieldName.str() + "'!\n";
if (ListInit *LI = dynamic_cast<ListInit*>(R->getValue())) if (ListInit *LI = dyn_cast<ListInit>(R->getValue()))
return LI; return LI;
throw "Record `" + getName() + "', field `" + FieldName.str() + throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a list initializer!"; "' does not have a list initializer!";
@ -1820,7 +1820,7 @@ Record::getValueAsListOfDefs(StringRef FieldName) const {
ListInit *List = getValueAsListInit(FieldName); ListInit *List = getValueAsListInit(FieldName);
std::vector<Record*> Defs; std::vector<Record*> Defs;
for (unsigned i = 0; i < List->getSize(); i++) { for (unsigned i = 0; i < List->getSize(); i++) {
if (DefInit *DI = dynamic_cast<DefInit*>(List->getElement(i))) { if (DefInit *DI = dyn_cast<DefInit>(List->getElement(i))) {
Defs.push_back(DI->getDef()); Defs.push_back(DI->getDef());
} else { } else {
throw "Record `" + getName() + "', field `" + FieldName.str() + throw "Record `" + getName() + "', field `" + FieldName.str() +
@ -1840,7 +1840,7 @@ int64_t Record::getValueAsInt(StringRef FieldName) const {
throw "Record `" + getName() + "' does not have a field named `" + throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n"; FieldName.str() + "'!\n";
if (IntInit *II = dynamic_cast<IntInit*>(R->getValue())) if (IntInit *II = dyn_cast<IntInit>(R->getValue()))
return II->getValue(); return II->getValue();
throw "Record `" + getName() + "', field `" + FieldName.str() + throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have an int initializer!"; "' does not have an int initializer!";
@ -1855,7 +1855,7 @@ Record::getValueAsListOfInts(StringRef FieldName) const {
ListInit *List = getValueAsListInit(FieldName); ListInit *List = getValueAsListInit(FieldName);
std::vector<int64_t> Ints; std::vector<int64_t> Ints;
for (unsigned i = 0; i < List->getSize(); i++) { for (unsigned i = 0; i < List->getSize(); i++) {
if (IntInit *II = dynamic_cast<IntInit*>(List->getElement(i))) { if (IntInit *II = dyn_cast<IntInit>(List->getElement(i))) {
Ints.push_back(II->getValue()); Ints.push_back(II->getValue());
} else { } else {
throw "Record `" + getName() + "', field `" + FieldName.str() + throw "Record `" + getName() + "', field `" + FieldName.str() +
@ -1874,7 +1874,7 @@ Record::getValueAsListOfStrings(StringRef FieldName) const {
ListInit *List = getValueAsListInit(FieldName); ListInit *List = getValueAsListInit(FieldName);
std::vector<std::string> Strings; std::vector<std::string> Strings;
for (unsigned i = 0; i < List->getSize(); i++) { for (unsigned i = 0; i < List->getSize(); i++) {
if (StringInit *II = dynamic_cast<StringInit*>(List->getElement(i))) { if (StringInit *II = dyn_cast<StringInit>(List->getElement(i))) {
Strings.push_back(II->getValue()); Strings.push_back(II->getValue());
} else { } else {
throw "Record `" + getName() + "', field `" + FieldName.str() + throw "Record `" + getName() + "', field `" + FieldName.str() +
@ -1894,7 +1894,7 @@ Record *Record::getValueAsDef(StringRef FieldName) const {
throw "Record `" + getName() + "' does not have a field named `" + throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n"; FieldName.str() + "'!\n";
if (DefInit *DI = dynamic_cast<DefInit*>(R->getValue())) if (DefInit *DI = dyn_cast<DefInit>(R->getValue()))
return DI->getDef(); return DI->getDef();
throw "Record `" + getName() + "', field `" + FieldName.str() + throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a def initializer!"; "' does not have a def initializer!";
@ -1910,7 +1910,7 @@ bool Record::getValueAsBit(StringRef FieldName) const {
throw "Record `" + getName() + "' does not have a field named `" + throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n"; FieldName.str() + "'!\n";
if (BitInit *BI = dynamic_cast<BitInit*>(R->getValue())) if (BitInit *BI = dyn_cast<BitInit>(R->getValue()))
return BI->getValue(); return BI->getValue();
throw "Record `" + getName() + "', field `" + FieldName.str() + throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a bit initializer!"; "' does not have a bit initializer!";
@ -1927,7 +1927,7 @@ bool Record::getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const {
return false; return false;
} }
Unset = false; Unset = false;
if (BitInit *BI = dynamic_cast<BitInit*>(R->getValue())) if (BitInit *BI = dyn_cast<BitInit>(R->getValue()))
return BI->getValue(); return BI->getValue();
throw "Record `" + getName() + "', field `" + FieldName.str() + throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a bit initializer!"; "' does not have a bit initializer!";
@ -1943,7 +1943,7 @@ DagInit *Record::getValueAsDag(StringRef FieldName) const {
throw "Record `" + getName() + "' does not have a field named `" + throw "Record `" + getName() + "' does not have a field named `" +
FieldName.str() + "'!\n"; FieldName.str() + "'!\n";
if (DagInit *DI = dynamic_cast<DagInit*>(R->getValue())) if (DagInit *DI = dyn_cast<DagInit>(R->getValue()))
return DI; return DI;
throw "Record `" + getName() + "', field `" + FieldName.str() + throw "Record `" + getName() + "', field `" + FieldName.str() +
"' does not have a dag initializer!"; "' does not have a dag initializer!";
@ -2004,7 +2004,7 @@ RecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const {
/// to CurRec's name. /// to CurRec's name.
Init *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass, Init *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass,
Init *Name, const std::string &Scoper) { Init *Name, const std::string &Scoper) {
RecTy *Type = dynamic_cast<TypedInit *>(Name)->getType(); RecTy *Type = dyn_cast<TypedInit>(Name)->getType();
BinOpInit *NewName = BinOpInit *NewName =
BinOpInit::get(BinOpInit::STRCONCAT, BinOpInit::get(BinOpInit::STRCONCAT,

52
llvm/lib/TableGen/TGParser.cpp
View File

@ -93,7 +93,7 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName,
// Do not allow assignments like 'X = X'. This will just cause infinite loops // Do not allow assignments like 'X = X'. This will just cause infinite loops
// in the resolution machinery. // in the resolution machinery.
if (BitList.empty()) if (BitList.empty())
if (VarInit *VI = dynamic_cast<VarInit*>(V)) if (VarInit *VI = dyn_cast<VarInit>(V))
if (VI->getNameInit() == ValName) if (VI->getNameInit() == ValName)
return false; return false;
@ -102,7 +102,7 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName,
// initializer. // initializer.
// //
if (!BitList.empty()) { if (!BitList.empty()) {
BitsInit *CurVal = dynamic_cast<BitsInit*>(RV->getValue()); BitsInit *CurVal = dyn_cast<BitsInit>(RV->getValue());
if (CurVal == 0) if (CurVal == 0)
return Error(Loc, "Value '" + ValName->getAsUnquotedString() return Error(Loc, "Value '" + ValName->getAsUnquotedString()
+ "' is not a bits type"); + "' is not a bits type");
@ -114,7 +114,7 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName,
} }
// We should have a BitsInit type now. // We should have a BitsInit type now.
BitsInit *BInit = dynamic_cast<BitsInit*>(BI); BitsInit *BInit = dyn_cast<BitsInit>(BI);
assert(BInit != 0); assert(BInit != 0);
SmallVector<Init *, 16> NewBits(CurVal->getNumBits()); SmallVector<Init *, 16> NewBits(CurVal->getNumBits());
@ -310,7 +310,7 @@ bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals){
if (IterVals.size() != Loops.size()) { if (IterVals.size() != Loops.size()) {
assert(IterVals.size() < Loops.size()); assert(IterVals.size() < Loops.size());
ForeachLoop &CurLoop = Loops[IterVals.size()]; ForeachLoop &CurLoop = Loops[IterVals.size()];
ListInit *List = dynamic_cast<ListInit *>(CurLoop.ListValue); ListInit *List = dyn_cast<ListInit>(CurLoop.ListValue);
if (List == 0) { if (List == 0) {
Error(Loc, "Loop list is not a list"); Error(Loc, "Loop list is not a list");
return true; return true;
@ -335,7 +335,7 @@ bool TGParser::ProcessForeachDefs(Record *CurRec, SMLoc Loc, IterSet &IterVals){
// Set the iterator values now. // Set the iterator values now.
for (unsigned i = 0, e = IterVals.size(); i != e; ++i) { for (unsigned i = 0, e = IterVals.size(); i != e; ++i) {
VarInit *IterVar = IterVals[i].IterVar; VarInit *IterVar = IterVals[i].IterVar;
TypedInit *IVal = dynamic_cast<TypedInit *>(IterVals[i].IterValue); TypedInit *IVal = dyn_cast<TypedInit>(IterVals[i].IterValue);
if (IVal == 0) { if (IVal == 0) {
Error(Loc, "foreach iterator value is untyped"); Error(Loc, "foreach iterator value is untyped");
return true; return true;
@ -407,7 +407,7 @@ Init *TGParser::ParseObjectName(MultiClass *CurMultiClass) {
RecTy *Type = 0; RecTy *Type = 0;
if (CurRec) { if (CurRec) {
const TypedInit *CurRecName = const TypedInit *CurRecName =
dynamic_cast<const TypedInit *>(CurRec->getNameInit()); dyn_cast<TypedInit>(CurRec->getNameInit());
if (!CurRecName) { if (!CurRecName) {
TokError("Record name is not typed!"); TokError("Record name is not typed!");
return 0; return 0;
@ -780,7 +780,7 @@ Init *TGParser::ParseIDValue(Record *CurRec,
for (LoopVector::iterator i = Loops.begin(), iend = Loops.end(); for (LoopVector::iterator i = Loops.begin(), iend = Loops.end();
i != iend; i != iend;
++i) { ++i) {
VarInit *IterVar = dynamic_cast<VarInit *>(i->IterVar); VarInit *IterVar = dyn_cast<VarInit>(i->IterVar);
if (IterVar && IterVar->getName() == Name) if (IterVar && IterVar->getName() == Name)
return IterVar; return IterVar;
} }
@ -855,9 +855,9 @@ Init *TGParser::ParseOperation(Record *CurRec) {
if (Code == UnOpInit::HEAD if (Code == UnOpInit::HEAD
|| Code == UnOpInit::TAIL || Code == UnOpInit::TAIL
|| Code == UnOpInit::EMPTY) { || Code == UnOpInit::EMPTY) {
ListInit *LHSl = dynamic_cast<ListInit*>(LHS); ListInit *LHSl = dyn_cast<ListInit>(LHS);
StringInit *LHSs = dynamic_cast<StringInit*>(LHS); StringInit *LHSs = dyn_cast<StringInit>(LHS);
TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS); TypedInit *LHSt = dyn_cast<TypedInit>(LHS);
if (LHSl == 0 && LHSs == 0 && LHSt == 0) { if (LHSl == 0 && LHSs == 0 && LHSt == 0) {
TokError("expected list or string type argument in unary operator"); TokError("expected list or string type argument in unary operator");
return 0; return 0;
@ -884,7 +884,7 @@ Init *TGParser::ParseOperation(Record *CurRec) {
} }
if (LHSl) { if (LHSl) {
Init *Item = LHSl->getElement(0); Init *Item = LHSl->getElement(0);
TypedInit *Itemt = dynamic_cast<TypedInit*>(Item); TypedInit *Itemt = dyn_cast<TypedInit>(Item);
if (Itemt == 0) { if (Itemt == 0) {
TokError("untyped list element in unary operator"); TokError("untyped list element in unary operator");
return 0; return 0;
@ -1046,24 +1046,24 @@ Init *TGParser::ParseOperation(Record *CurRec) {
RecTy *MHSTy = 0; RecTy *MHSTy = 0;
RecTy *RHSTy = 0; RecTy *RHSTy = 0;
if (TypedInit *MHSt = dynamic_cast<TypedInit*>(MHS)) if (TypedInit *MHSt = dyn_cast<TypedInit>(MHS))
MHSTy = MHSt->getType(); MHSTy = MHSt->getType();
if (BitsInit *MHSbits = dynamic_cast<BitsInit*>(MHS)) if (BitsInit *MHSbits = dyn_cast<BitsInit>(MHS))
MHSTy = BitsRecTy::get(MHSbits->getNumBits()); MHSTy = BitsRecTy::get(MHSbits->getNumBits());
if (dynamic_cast<BitInit*>(MHS)) if (dyn_cast<BitInit>(MHS))
MHSTy = BitRecTy::get(); MHSTy = BitRecTy::get();
if (TypedInit *RHSt = dynamic_cast<TypedInit*>(RHS)) if (TypedInit *RHSt = dyn_cast<TypedInit>(RHS))
RHSTy = RHSt->getType(); RHSTy = RHSt->getType();
if (BitsInit *RHSbits = dynamic_cast<BitsInit*>(RHS)) if (BitsInit *RHSbits = dyn_cast<BitsInit>(RHS))
RHSTy = BitsRecTy::get(RHSbits->getNumBits()); RHSTy = BitsRecTy::get(RHSbits->getNumBits());
if (dynamic_cast<BitInit*>(RHS)) if (dyn_cast<BitInit>(RHS))
RHSTy = BitRecTy::get(); RHSTy = BitRecTy::get();
// For UnsetInit, it's typed from the other hand. // For UnsetInit, it's typed from the other hand.
if (dynamic_cast<UnsetInit*>(MHS)) if (dyn_cast<UnsetInit>(MHS))
MHSTy = RHSTy; MHSTy = RHSTy;
if (dynamic_cast<UnsetInit*>(RHS)) if (dyn_cast<UnsetInit>(RHS))
RHSTy = MHSTy; RHSTy = MHSTy;
if (!MHSTy || !RHSTy) { if (!MHSTy || !RHSTy) {
@ -1082,7 +1082,7 @@ Init *TGParser::ParseOperation(Record *CurRec) {
break; break;
} }
case tgtok::XForEach: { case tgtok::XForEach: {
TypedInit *MHSt = dynamic_cast<TypedInit *>(MHS); TypedInit *MHSt = dyn_cast<TypedInit>(MHS);
if (MHSt == 0) { if (MHSt == 0) {
TokError("could not get type for !foreach"); TokError("could not get type for !foreach");
return 0; return 0;
@ -1091,7 +1091,7 @@ Init *TGParser::ParseOperation(Record *CurRec) {
break; break;
} }
case tgtok::XSubst: { case tgtok::XSubst: {
TypedInit *RHSt = dynamic_cast<TypedInit *>(RHS); TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
if (RHSt == 0) { if (RHSt == 0) {
TokError("could not get type for !subst"); TokError("could not get type for !subst");
return 0; return 0;
@ -1315,7 +1315,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
for (std::vector<Init *>::iterator i = Vals.begin(), ie = Vals.end(); for (std::vector<Init *>::iterator i = Vals.begin(), ie = Vals.end();
i != ie; i != ie;
++i) { ++i) {
TypedInit *TArg = dynamic_cast<TypedInit*>(*i); TypedInit *TArg = dyn_cast<TypedInit>(*i);
if (TArg == 0) { if (TArg == 0) {
TokError("Untyped list element"); TokError("Untyped list element");
return 0; return 0;
@ -1498,7 +1498,7 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
// Create a !strconcat() operation, first casting each operand to // Create a !strconcat() operation, first casting each operand to
// a string if necessary. // a string if necessary.
TypedInit *LHS = dynamic_cast<TypedInit *>(Result); TypedInit *LHS = dyn_cast<TypedInit>(Result);
if (!LHS) { if (!LHS) {
Error(PasteLoc, "LHS of paste is not typed!"); Error(PasteLoc, "LHS of paste is not typed!");
return 0; return 0;
@ -1525,7 +1525,7 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
default: default:
Init *RHSResult = ParseValue(CurRec, ItemType, ParseNameMode); Init *RHSResult = ParseValue(CurRec, ItemType, ParseNameMode);
RHS = dynamic_cast<TypedInit *>(RHSResult); RHS = dyn_cast<TypedInit>(RHSResult);
if (!RHS) { if (!RHS) {
Error(PasteLoc, "RHS of paste is not typed!"); Error(PasteLoc, "RHS of paste is not typed!");
return 0; return 0;
@ -1716,7 +1716,7 @@ VarInit *TGParser::ParseForeachDeclaration(ListInit *&ForeachListValue) {
default: TokError("Unknown token when expecting a range list"); return 0; default: TokError("Unknown token when expecting a range list"); return 0;
case tgtok::l_square: { // '[' ValueList ']' case tgtok::l_square: { // '[' ValueList ']'
Init *List = ParseSimpleValue(0, 0, ParseForeachMode); Init *List = ParseSimpleValue(0, 0, ParseForeachMode);
ForeachListValue = dynamic_cast<ListInit*>(List); ForeachListValue = dyn_cast<ListInit>(List);
if (ForeachListValue == 0) { if (ForeachListValue == 0) {
TokError("Expected a Value list"); TokError("Expected a Value list");
return 0; return 0;
@ -2257,7 +2257,7 @@ InstantiateMulticlassDef(MultiClass &MC,
Init *DefName = DefProto->getNameInit(); Init *DefName = DefProto->getNameInit();
StringInit *DefNameString = dynamic_cast<StringInit *>(DefName); StringInit *DefNameString = dyn_cast<StringInit>(DefName);
if (DefNameString != 0) { if (DefNameString != 0) {
// We have a fully expanded string so there are no operators to // We have a fully expanded string so there are no operators to

18
llvm/utils/TableGen/AsmMatcherEmitter.cpp
View File

@ -993,7 +993,7 @@ AsmMatcherInfo::getOperandClass(const CGIOperandList::OperandInfo &OI,
int SubOpIdx) { int SubOpIdx) {
Record *Rec = OI.Rec; Record *Rec = OI.Rec;
if (SubOpIdx != -1) if (SubOpIdx != -1)
Rec = dynamic_cast<DefInit*>(OI.MIOperandInfo->getArg(SubOpIdx))->getDef(); Rec = dyn_cast<DefInit>(OI.MIOperandInfo->getArg(SubOpIdx))->getDef();
return getOperandClass(Rec, SubOpIdx); return getOperandClass(Rec, SubOpIdx);
} }
@ -1007,7 +1007,7 @@ AsmMatcherInfo::getOperandClass(Record *Rec, int SubOpIdx) {
throw "Record `" + Rec->getName() + throw "Record `" + Rec->getName() +
"' does not have a ParserMatchClass!\n"; "' does not have a ParserMatchClass!\n";
if (DefInit *DI= dynamic_cast<DefInit*>(R->getValue())) { if (DefInit *DI= dyn_cast<DefInit>(R->getValue())) {
Record *MatchClass = DI->getDef(); Record *MatchClass = DI->getDef();
if (ClassInfo *CI = AsmOperandClasses[MatchClass]) if (ClassInfo *CI = AsmOperandClasses[MatchClass])
return CI; return CI;
@ -1185,7 +1185,7 @@ void AsmMatcherInfo::buildOperandClasses() {
ListInit *Supers = (*it)->getValueAsListInit("SuperClasses"); ListInit *Supers = (*it)->getValueAsListInit("SuperClasses");
for (unsigned i = 0, e = Supers->getSize(); i != e; ++i) { for (unsigned i = 0, e = Supers->getSize(); i != e; ++i) {
DefInit *DI = dynamic_cast<DefInit*>(Supers->getElement(i)); DefInit *DI = dyn_cast<DefInit>(Supers->getElement(i));
if (!DI) { if (!DI) {
PrintError((*it)->getLoc(), "Invalid super class reference!"); PrintError((*it)->getLoc(), "Invalid super class reference!");
continue; continue;
@ -1203,33 +1203,33 @@ void AsmMatcherInfo::buildOperandClasses() {
// Get or construct the predicate method name. // Get or construct the predicate method name.
Init *PMName = (*it)->getValueInit("PredicateMethod"); Init *PMName = (*it)->getValueInit("PredicateMethod");
if (StringInit *SI = dynamic_cast<StringInit*>(PMName)) { if (StringInit *SI = dyn_cast<StringInit>(PMName)) {
CI->PredicateMethod = SI->getValue(); CI->PredicateMethod = SI->getValue();
} else { } else {
assert(dynamic_cast<UnsetInit*>(PMName) && assert(dyn_cast<UnsetInit>(PMName) &&
"Unexpected PredicateMethod field!"); "Unexpected PredicateMethod field!");
CI->PredicateMethod = "is" + CI->ClassName; CI->PredicateMethod = "is" + CI->ClassName;
} }
// Get or construct the render method name. // Get or construct the render method name.
Init *RMName = (*it)->getValueInit("RenderMethod"); Init *RMName = (*it)->getValueInit("RenderMethod");
if (StringInit *SI = dynamic_cast<StringInit*>(RMName)) { if (StringInit *SI = dyn_cast<StringInit>(RMName)) {
CI->RenderMethod = SI->getValue(); CI->RenderMethod = SI->getValue();
} else { } else {
assert(dynamic_cast<UnsetInit*>(RMName) && assert(dyn_cast<UnsetInit>(RMName) &&
"Unexpected RenderMethod field!"); "Unexpected RenderMethod field!");
CI->RenderMethod = "add" + CI->ClassName + "Operands"; CI->RenderMethod = "add" + CI->ClassName + "Operands";
} }
// Get the parse method name or leave it as empty. // Get the parse method name or leave it as empty.
Init *PRMName = (*it)->getValueInit("ParserMethod"); Init *PRMName = (*it)->getValueInit("ParserMethod");
if (StringInit *SI = dynamic_cast<StringInit*>(PRMName)) if (StringInit *SI = dyn_cast<StringInit>(PRMName))
CI->ParserMethod = SI->getValue(); CI->ParserMethod = SI->getValue();
// Get the diagnostic type or leave it as empty. // Get the diagnostic type or leave it as empty.
// Get the parse method name or leave it as empty. // Get the parse method name or leave it as empty.
Init *DiagnosticType = (*it)->getValueInit("DiagnosticType"); Init *DiagnosticType = (*it)->getValueInit("DiagnosticType");
if (StringInit *SI = dynamic_cast<StringInit*>(DiagnosticType)) if (StringInit *SI = dyn_cast<StringInit>(DiagnosticType))
CI->DiagnosticType = SI->getValue(); CI->DiagnosticType = SI->getValue();
AsmOperandClasses[*it] = CI; AsmOperandClasses[*it] = CI;

2
llvm/utils/TableGen/AsmWriterEmitter.cpp
View File

@ -792,7 +792,7 @@ void AsmWriterEmitter::EmitPrintAliasInstruction(raw_ostream &O) {
if (!R->getValueAsBit("EmitAlias")) if (!R->getValueAsBit("EmitAlias"))
continue; // We were told not to emit the alias, but to emit the aliasee. continue; // We were told not to emit the alias, but to emit the aliasee.
const DagInit *DI = R->getValueAsDag("ResultInst"); const DagInit *DI = R->getValueAsDag("ResultInst");
const DefInit *Op = dynamic_cast<const DefInit*>(DI->getOperator()); const DefInit *Op = dyn_cast<DefInit>(DI->getOperator());
AliasMap[getQualifiedName(Op->getDef())].push_back(Alias); AliasMap[getQualifiedName(Op->getDef())].push_back(Alias);
} }

8
llvm/utils/TableGen/CodeEmitterGen.cpp
View File

@ -91,11 +91,11 @@ void CodeEmitterGen::reverseBits(std::vector<Record*> &Insts) {
// return the variable bit position. Otherwise return -1. // return the variable bit position. Otherwise return -1.
int CodeEmitterGen::getVariableBit(const std::string &VarName, int CodeEmitterGen::getVariableBit(const std::string &VarName,
BitsInit *BI, int bit) { BitsInit *BI, int bit) {
if (VarBitInit *VBI = dynamic_cast<VarBitInit*>(BI->getBit(bit))) { if (VarBitInit *VBI = dyn_cast<VarBitInit>(BI->getBit(bit))) {
if (VarInit *VI = dynamic_cast<VarInit*>(VBI->getBitVar())) if (VarInit *VI = dyn_cast<VarInit>(VBI->getBitVar()))
if (VI->getName() == VarName) if (VI->getName() == VarName)
return VBI->getBitNum(); return VBI->getBitNum();
} else if (VarInit *VI = dynamic_cast<VarInit*>(BI->getBit(bit))) { } else if (VarInit *VI = dyn_cast<VarInit>(BI->getBit(bit))) {
if (VI->getName() == VarName) if (VI->getName() == VarName)
return 0; return 0;
} }
@ -269,7 +269,7 @@ void CodeEmitterGen::run(raw_ostream &o) {
// Start by filling in fixed values. // Start by filling in fixed values.
uint64_t Value = 0; uint64_t Value = 0;
for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) { for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) {
if (BitInit *B = dynamic_cast<BitInit*>(BI->getBit(e-i-1))) if (BitInit *B = dyn_cast<BitInit>(BI->getBit(e-i-1)))
Value |= (uint64_t)B->getValue() << (e-i-1); Value |= (uint64_t)B->getValue() << (e-i-1);
} }
o << " UINT64_C(" << Value << ")," << '\t' << "// " << R->getName() << "\n"; o << " UINT64_C(" << Value << ")," << '\t' << "// " << R->getName() << "\n";

76
llvm/utils/TableGen/CodeGenDAGPatterns.cpp
View File

@ -582,7 +582,7 @@ typedef DepVarMap::const_iterator DepVarMap_citer;
static void FindDepVarsOf(TreePatternNode *N, DepVarMap &DepMap) { static void FindDepVarsOf(TreePatternNode *N, DepVarMap &DepMap) {
if (N->isLeaf()) { if (N->isLeaf()) {
if (dynamic_cast<DefInit*>(N->getLeafValue()) != NULL) if (dyn_cast<DefInit>(N->getLeafValue()) != NULL)
DepMap[N->getName()]++; DepMap[N->getName()]++;
} else { } else {
for (size_t i = 0, e = N->getNumChildren(); i != e; ++i) for (size_t i = 0, e = N->getNumChildren(); i != e; ++i)
@ -691,7 +691,7 @@ static unsigned getPatternSize(const TreePatternNode *P,
unsigned Size = 3; // The node itself. unsigned Size = 3; // The node itself.
// If the root node is a ConstantSDNode, increases its size. // If the root node is a ConstantSDNode, increases its size.
// e.g. (set R32:$dst, 0). // e.g. (set R32:$dst, 0).
if (P->isLeaf() && dynamic_cast<IntInit*>(P->getLeafValue())) if (P->isLeaf() && dyn_cast<IntInit>(P->getLeafValue()))
Size += 2; Size += 2;
// FIXME: This is a hack to statically increase the priority of patterns // FIXME: This is a hack to statically increase the priority of patterns
@ -715,7 +715,7 @@ static unsigned getPatternSize(const TreePatternNode *P,
Child->getType(0) != MVT::Other) Child->getType(0) != MVT::Other)
Size += getPatternSize(Child, CGP); Size += getPatternSize(Child, CGP);
else if (Child->isLeaf()) { else if (Child->isLeaf()) {
if (dynamic_cast<IntInit*>(Child->getLeafValue())) if (dyn_cast<IntInit>(Child->getLeafValue()))
Size += 5; // Matches a ConstantSDNode (+3) and a specific value (+2). Size += 5; // Matches a ConstantSDNode (+3) and a specific value (+2).
else if (Child->getComplexPatternInfo(CGP)) else if (Child->getComplexPatternInfo(CGP))
Size += getPatternSize(Child, CGP); Size += getPatternSize(Child, CGP);
@ -741,7 +741,7 @@ getPatternComplexity(const CodeGenDAGPatterns &CGP) const {
std::string PatternToMatch::getPredicateCheck() const { std::string PatternToMatch::getPredicateCheck() const {
std::string PredicateCheck; std::string PredicateCheck;
for (unsigned i = 0, e = Predicates->getSize(); i != e; ++i) { for (unsigned i = 0, e = Predicates->getSize(); i != e; ++i) {
if (DefInit *Pred = dynamic_cast<DefInit*>(Predicates->getElement(i))) { if (DefInit *Pred = dyn_cast<DefInit>(Predicates->getElement(i))) {
Record *Def = Pred->getDef(); Record *Def = Pred->getDef();
if (!Def->isSubClassOf("Predicate")) { if (!Def->isSubClassOf("Predicate")) {
#ifndef NDEBUG #ifndef NDEBUG
@ -864,7 +864,7 @@ bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N,
// The NodeToApply must be a leaf node that is a VT. OtherOperandNum must // The NodeToApply must be a leaf node that is a VT. OtherOperandNum must
// have an integer type that is smaller than the VT. // have an integer type that is smaller than the VT.
if (!NodeToApply->isLeaf() || if (!NodeToApply->isLeaf() ||
!dynamic_cast<DefInit*>(NodeToApply->getLeafValue()) || !dyn_cast<DefInit>(NodeToApply->getLeafValue()) ||
!static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef() !static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef()
->isSubClassOf("ValueType")) ->isSubClassOf("ValueType"))
TP.error(N->getOperator()->getName() + " expects a VT operand!"); TP.error(N->getOperator()->getName() + " expects a VT operand!");
@ -1021,8 +1021,8 @@ static unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) {
// Get the result tree. // Get the result tree.
DagInit *Tree = Operator->getValueAsDag("Fragment"); DagInit *Tree = Operator->getValueAsDag("Fragment");
Record *Op = 0; Record *Op = 0;
if (Tree && dynamic_cast<DefInit*>(Tree->getOperator())) if (Tree && dyn_cast<DefInit>(Tree->getOperator()))
Op = dynamic_cast<DefInit*>(Tree->getOperator())->getDef(); Op = dyn_cast<DefInit>(Tree->getOperator())->getDef();
assert(Op && "Invalid Fragment"); assert(Op && "Invalid Fragment");
return GetNumNodeResults(Op, CDP); return GetNumNodeResults(Op, CDP);
} }
@ -1096,8 +1096,8 @@ bool TreePatternNode::isIsomorphicTo(const TreePatternNode *N,
return false; return false;
if (isLeaf()) { if (isLeaf()) {
if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) { if (DefInit *DI = dyn_cast<DefInit>(getLeafValue())) {
if (DefInit *NDI = dynamic_cast<DefInit*>(N->getLeafValue())) { if (DefInit *NDI = dyn_cast<DefInit>(N->getLeafValue())) {
return ((DI->getDef() == NDI->getDef()) return ((DI->getDef() == NDI->getDef())
&& (DepVars.find(getName()) == DepVars.end() && (DepVars.find(getName()) == DepVars.end()
|| getName() == N->getName())); || getName() == N->getName()));
@ -1154,7 +1154,7 @@ SubstituteFormalArguments(std::map<std::string, TreePatternNode*> &ArgMap) {
TreePatternNode *Child = getChild(i); TreePatternNode *Child = getChild(i);
if (Child->isLeaf()) { if (Child->isLeaf()) {
Init *Val = Child->getLeafValue(); Init *Val = Child->getLeafValue();
if (dynamic_cast<DefInit*>(Val) && if (dyn_cast<DefInit>(Val) &&
static_cast<DefInit*>(Val)->getDef()->getName() == "node") { static_cast<DefInit*>(Val)->getDef()->getName() == "node") {
// We found a use of a formal argument, replace it with its value. // We found a use of a formal argument, replace it with its value.
TreePatternNode *NewChild = ArgMap[Child->getName()]; TreePatternNode *NewChild = ArgMap[Child->getName()];
@ -1317,7 +1317,7 @@ getIntrinsicInfo(const CodeGenDAGPatterns &CDP) const {
return 0; return 0;
unsigned IID = unsigned IID =
dynamic_cast<IntInit*>(getChild(0)->getLeafValue())->getValue(); dyn_cast<IntInit>(getChild(0)->getLeafValue())->getValue();
return &CDP.getIntrinsicInfo(IID); return &CDP.getIntrinsicInfo(IID);
} }
@ -1327,7 +1327,7 @@ const ComplexPattern *
TreePatternNode::getComplexPatternInfo(const CodeGenDAGPatterns &CGP) const { TreePatternNode::getComplexPatternInfo(const CodeGenDAGPatterns &CGP) const {
if (!isLeaf()) return 0; if (!isLeaf()) return 0;
DefInit *DI = dynamic_cast<DefInit*>(getLeafValue()); DefInit *DI = dyn_cast<DefInit>(getLeafValue());
if (DI && DI->getDef()->isSubClassOf("ComplexPattern")) if (DI && DI->getDef()->isSubClassOf("ComplexPattern"))
return &CGP.getComplexPattern(DI->getDef()); return &CGP.getComplexPattern(DI->getDef());
return 0; return 0;
@ -1380,7 +1380,7 @@ TreePatternNode::isCommutativeIntrinsic(const CodeGenDAGPatterns &CDP) const {
bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) { bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
CodeGenDAGPatterns &CDP = TP.getDAGPatterns(); CodeGenDAGPatterns &CDP = TP.getDAGPatterns();
if (isLeaf()) { if (isLeaf()) {
if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) { if (DefInit *DI = dyn_cast<DefInit>(getLeafValue())) {
// If it's a regclass or something else known, include the type. // If it's a regclass or something else known, include the type.
bool MadeChange = false; bool MadeChange = false;
for (unsigned i = 0, e = Types.size(); i != e; ++i) for (unsigned i = 0, e = Types.size(); i != e; ++i)
@ -1389,7 +1389,7 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
return MadeChange; return MadeChange;
} }
if (IntInit *II = dynamic_cast<IntInit*>(getLeafValue())) { if (IntInit *II = dyn_cast<IntInit>(getLeafValue())) {
assert(Types.size() == 1 && "Invalid IntInit"); assert(Types.size() == 1 && "Invalid IntInit");
// Int inits are always integers. :) // Int inits are always integers. :)
@ -1641,7 +1641,7 @@ bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
static bool OnlyOnRHSOfCommutative(TreePatternNode *N) { static bool OnlyOnRHSOfCommutative(TreePatternNode *N) {
if (!N->isLeaf() && N->getOperator()->getName() == "imm") if (!N->isLeaf() && N->getOperator()->getName() == "imm")
return true; return true;
if (N->isLeaf() && dynamic_cast<IntInit*>(N->getLeafValue())) if (N->isLeaf() && dyn_cast<IntInit>(N->getLeafValue()))
return true; return true;
return false; return false;
} }
@ -1730,7 +1730,7 @@ void TreePattern::ComputeNamedNodes(TreePatternNode *N) {
TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){ TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){
if (DefInit *DI = dynamic_cast<DefInit*>(TheInit)) { if (DefInit *DI = dyn_cast<DefInit>(TheInit)) {
Record *R = DI->getDef(); Record *R = DI->getDef();
// Direct reference to a leaf DagNode or PatFrag? Turn it into a // Direct reference to a leaf DagNode or PatFrag? Turn it into a
@ -1754,26 +1754,26 @@ TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){
return Res; return Res;
} }
if (IntInit *II = dynamic_cast<IntInit*>(TheInit)) { if (IntInit *II = dyn_cast<IntInit>(TheInit)) {
if (!OpName.empty()) if (!OpName.empty())
error("Constant int argument should not have a name!"); error("Constant int argument should not have a name!");
return new TreePatternNode(II, 1); return new TreePatternNode(II, 1);
} }
if (BitsInit *BI = dynamic_cast<BitsInit*>(TheInit)) { if (BitsInit *BI = dyn_cast<BitsInit>(TheInit)) {
// Turn this into an IntInit. // Turn this into an IntInit.
Init *II = BI->convertInitializerTo(IntRecTy::get()); Init *II = BI->convertInitializerTo(IntRecTy::get());
if (II == 0 || !dynamic_cast<IntInit*>(II)) if (II == 0 || !dyn_cast<IntInit>(II))
error("Bits value must be constants!"); error("Bits value must be constants!");
return ParseTreePattern(II, OpName); return ParseTreePattern(II, OpName);
} }
DagInit *Dag = dynamic_cast<DagInit*>(TheInit); DagInit *Dag = dyn_cast<DagInit>(TheInit);
if (!Dag) { if (!Dag) {
TheInit->dump(); TheInit->dump();
error("Pattern has unexpected init kind!"); error("Pattern has unexpected init kind!");
} }
DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator()); DefInit *OpDef = dyn_cast<DefInit>(Dag->getOperator());
if (!OpDef) error("Pattern has unexpected operator type!"); if (!OpDef) error("Pattern has unexpected operator type!");
Record *Operator = OpDef->getDef(); Record *Operator = OpDef->getDef();
@ -1938,7 +1938,7 @@ InferAllTypes(const StringMap<SmallVector<TreePatternNode*,1> > *InNamedTypes) {
// us to match things like: // us to match things like:
// def : Pat<(v1i64 (bitconvert(v2i32 DPR:$src))), (v1i64 DPR:$src)>; // def : Pat<(v1i64 (bitconvert(v2i32 DPR:$src))), (v1i64 DPR:$src)>;
if (Nodes[i] == Trees[0] && Nodes[i]->isLeaf()) { if (Nodes[i] == Trees[0] && Nodes[i]->isLeaf()) {
DefInit *DI = dynamic_cast<DefInit*>(Nodes[i]->getLeafValue()); DefInit *DI = dyn_cast<DefInit>(Nodes[i]->getLeafValue());
if (DI && (DI->getDef()->isSubClassOf("RegisterClass") || if (DI && (DI->getDef()->isSubClassOf("RegisterClass") ||
DI->getDef()->isSubClassOf("RegisterOperand"))) DI->getDef()->isSubClassOf("RegisterOperand")))
continue; continue;
@ -2103,7 +2103,7 @@ void CodeGenDAGPatterns::ParsePatternFragments() {
// Parse the operands list. // Parse the operands list.
DagInit *OpsList = Fragments[i]->getValueAsDag("Operands"); DagInit *OpsList = Fragments[i]->getValueAsDag("Operands");
DefInit *OpsOp = dynamic_cast<DefInit*>(OpsList->getOperator()); DefInit *OpsOp = dyn_cast<DefInit>(OpsList->getOperator());
// Special cases: ops == outs == ins. Different names are used to // Special cases: ops == outs == ins. Different names are used to
// improve readability. // improve readability.
if (!OpsOp || if (!OpsOp ||
@ -2115,7 +2115,7 @@ void CodeGenDAGPatterns::ParsePatternFragments() {
// Copy over the arguments. // Copy over the arguments.
Args.clear(); Args.clear();
for (unsigned j = 0, e = OpsList->getNumArgs(); j != e; ++j) { for (unsigned j = 0, e = OpsList->getNumArgs(); j != e; ++j) {
if (!dynamic_cast<DefInit*>(OpsList->getArg(j)) || if (!dyn_cast<DefInit>(OpsList->getArg(j)) ||
static_cast<DefInit*>(OpsList->getArg(j))-> static_cast<DefInit*>(OpsList->getArg(j))->
getDef()->getName() != "node") getDef()->getName() != "node")
P->error("Operands list should all be 'node' values."); P->error("Operands list should all be 'node' values.");
@ -2218,7 +2218,7 @@ static bool HandleUse(TreePattern *I, TreePatternNode *Pat,
// No name -> not interesting. // No name -> not interesting.
if (Pat->getName().empty()) { if (Pat->getName().empty()) {
if (Pat->isLeaf()) { if (Pat->isLeaf()) {
DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue()); DefInit *DI = dyn_cast<DefInit>(Pat->getLeafValue());
if (DI && (DI->getDef()->isSubClassOf("RegisterClass") || if (DI && (DI->getDef()->isSubClassOf("RegisterClass") ||
DI->getDef()->isSubClassOf("RegisterOperand"))) DI->getDef()->isSubClassOf("RegisterOperand")))
I->error("Input " + DI->getDef()->getName() + " must be named!"); I->error("Input " + DI->getDef()->getName() + " must be named!");
@ -2228,7 +2228,7 @@ static bool HandleUse(TreePattern *I, TreePatternNode *Pat,
Record *Rec; Record *Rec;
if (Pat->isLeaf()) { if (Pat->isLeaf()) {
DefInit *DI = dynamic_cast<DefInit*>(Pat->getLeafValue()); DefInit *DI = dyn_cast<DefInit>(Pat->getLeafValue());
if (!DI) I->error("Input $" + Pat->getName() + " must be an identifier!"); if (!DI) I->error("Input $" + Pat->getName() + " must be an identifier!");
Rec = DI->getDef(); Rec = DI->getDef();
} else { } else {
@ -2246,7 +2246,7 @@ static bool HandleUse(TreePattern *I, TreePatternNode *Pat,
} }
Record *SlotRec; Record *SlotRec;
if (Slot->isLeaf()) { if (Slot->isLeaf()) {
SlotRec = dynamic_cast<DefInit*>(Slot->getLeafValue())->getDef(); SlotRec = dyn_cast<DefInit>(Slot->getLeafValue())->getDef();
} else { } else {
assert(Slot->getNumChildren() == 0 && "can't be a use with children!"); assert(Slot->getNumChildren() == 0 && "can't be a use with children!");
SlotRec = Slot->getOperator(); SlotRec = Slot->getOperator();
@ -2281,7 +2281,7 @@ FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat,
if (!Dest->isLeaf()) if (!Dest->isLeaf())
I->error("implicitly defined value should be a register!"); I->error("implicitly defined value should be a register!");
DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue()); DefInit *Val = dyn_cast<DefInit>(Dest->getLeafValue());
if (!Val || !Val->getDef()->isSubClassOf("Register")) if (!Val || !Val->getDef()->isSubClassOf("Register"))
I->error("implicitly defined value should be a register!"); I->error("implicitly defined value should be a register!");
InstImpResults.push_back(Val->getDef()); InstImpResults.push_back(Val->getDef());
@ -2322,7 +2322,7 @@ FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat,
if (!Dest->isLeaf()) if (!Dest->isLeaf())
I->error("set destination should be a register!"); I->error("set destination should be a register!");
DefInit *Val = dynamic_cast<DefInit*>(Dest->getLeafValue()); DefInit *Val = dyn_cast<DefInit>(Dest->getLeafValue());
if (!Val) if (!Val)
I->error("set destination should be a register!"); I->error("set destination should be a register!");
@ -2381,7 +2381,7 @@ private:
return false; return false;
const TreePatternNode *N0 = N->getChild(0); const TreePatternNode *N0 = N->getChild(0);
if (!N0->isLeaf() || !dynamic_cast<DefInit*>(N0->getLeafValue())) if (!N0->isLeaf() || !dyn_cast<DefInit>(N0->getLeafValue()))
return false; return false;
const TreePatternNode *N1 = N->getChild(1); const TreePatternNode *N1 = N->getChild(1);
@ -2399,7 +2399,7 @@ private:
public: public:
void AnalyzeNode(const TreePatternNode *N) { void AnalyzeNode(const TreePatternNode *N) {
if (N->isLeaf()) { if (N->isLeaf()) {
if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) { if (DefInit *DI = dyn_cast<DefInit>(N->getLeafValue())) {
Record *LeafRec = DI->getDef(); Record *LeafRec = DI->getDef();
// Handle ComplexPattern leaves. // Handle ComplexPattern leaves.
if (LeafRec->isSubClassOf("ComplexPattern")) { if (LeafRec->isSubClassOf("ComplexPattern")) {
@ -2504,7 +2504,7 @@ static bool InferFromPattern(CodeGenInstruction &InstInfo,
/// hasNullFragReference - Return true if the DAG has any reference to the /// hasNullFragReference - Return true if the DAG has any reference to the
/// null_frag operator. /// null_frag operator.
static bool hasNullFragReference(DagInit *DI) { static bool hasNullFragReference(DagInit *DI) {
DefInit *OpDef = dynamic_cast<DefInit*>(DI->getOperator()); DefInit *OpDef = dyn_cast<DefInit>(DI->getOperator());
if (!OpDef) return false; if (!OpDef) return false;
Record *Operator = OpDef->getDef(); Record *Operator = OpDef->getDef();
@ -2512,7 +2512,7 @@ static bool hasNullFragReference(DagInit *DI) {
if (Operator->getName() == "null_frag") return true; if (Operator->getName() == "null_frag") return true;
// If any of the arguments reference the null fragment, return true. // If any of the arguments reference the null fragment, return true.
for (unsigned i = 0, e = DI->getNumArgs(); i != e; ++i) { for (unsigned i = 0, e = DI->getNumArgs(); i != e; ++i) {
DagInit *Arg = dynamic_cast<DagInit*>(DI->getArg(i)); DagInit *Arg = dyn_cast<DagInit>(DI->getArg(i));
if (Arg && hasNullFragReference(Arg)) if (Arg && hasNullFragReference(Arg))
return true; return true;
} }
@ -2524,7 +2524,7 @@ static bool hasNullFragReference(DagInit *DI) {
/// the null_frag operator. /// the null_frag operator.
static bool hasNullFragReference(ListInit *LI) { static bool hasNullFragReference(ListInit *LI) {
for (unsigned i = 0, e = LI->getSize(); i != e; ++i) { for (unsigned i = 0, e = LI->getSize(); i != e; ++i) {
DagInit *DI = dynamic_cast<DagInit*>(LI->getElement(i)); DagInit *DI = dyn_cast<DagInit>(LI->getElement(i));
assert(DI && "non-dag in an instruction Pattern list?!"); assert(DI && "non-dag in an instruction Pattern list?!");
if (hasNullFragReference(DI)) if (hasNullFragReference(DI))
return true; return true;
@ -2552,7 +2552,7 @@ void CodeGenDAGPatterns::ParseInstructions() {
for (unsigned i = 0, e = Instrs.size(); i != e; ++i) { for (unsigned i = 0, e = Instrs.size(); i != e; ++i) {
ListInit *LI = 0; ListInit *LI = 0;
if (dynamic_cast<ListInit*>(Instrs[i]->getValueInit("Pattern"))) if (dyn_cast<ListInit>(Instrs[i]->getValueInit("Pattern")))
LI = Instrs[i]->getValueAsListInit("Pattern"); LI = Instrs[i]->getValueAsListInit("Pattern");
// If there is no pattern, only collect minimal information about the // If there is no pattern, only collect minimal information about the
@ -2647,7 +2647,7 @@ void CodeGenDAGPatterns::ParseInstructions() {
if (i == 0) if (i == 0)
Res0Node = RNode; Res0Node = RNode;
Record *R = dynamic_cast<DefInit*>(RNode->getLeafValue())->getDef(); Record *R = dyn_cast<DefInit>(RNode->getLeafValue())->getDef();
if (R == 0) if (R == 0)
I->error("Operand $" + OpName + " should be a set destination: all " I->error("Operand $" + OpName + " should be a set destination: all "
"outputs must occur before inputs in operand list!"); "outputs must occur before inputs in operand list!");
@ -2690,7 +2690,7 @@ void CodeGenDAGPatterns::ParseInstructions() {
InstInputsCheck.erase(OpName); // It occurred, remove from map. InstInputsCheck.erase(OpName); // It occurred, remove from map.
if (InVal->isLeaf() && if (InVal->isLeaf() &&
dynamic_cast<DefInit*>(InVal->getLeafValue())) { dyn_cast<DefInit>(InVal->getLeafValue())) {
Record *InRec = static_cast<DefInit*>(InVal->getLeafValue())->getDef(); Record *InRec = static_cast<DefInit*>(InVal->getLeafValue())->getDef();
if (Op.Rec != InRec && !InRec->isSubClassOf("ComplexPattern")) if (Op.Rec != InRec && !InRec->isSubClassOf("ComplexPattern"))
I->error("Operand $" + OpName + "'s register class disagrees" I->error("Operand $" + OpName + "'s register class disagrees"
@ -3354,7 +3354,7 @@ static void GenerateVariantsOf(TreePatternNode *N,
for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) { for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) {
TreePatternNode *Child = N->getChild(i); TreePatternNode *Child = N->getChild(i);
if (Child->isLeaf()) if (Child->isLeaf())
if (DefInit *DI = dynamic_cast<DefInit*>(Child->getLeafValue())) { if (DefInit *DI = dyn_cast<DefInit>(Child->getLeafValue())) {
Record *RR = DI->getDef(); Record *RR = DI->getDef();
if (RR->isSubClassOf("Register")) if (RR->isSubClassOf("Register"))
continue; continue;

24
llvm/utils/TableGen/CodeGenInstruction.cpp
View File

@ -32,7 +32,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
DagInit *OutDI = R->getValueAsDag("OutOperandList"); DagInit *OutDI = R->getValueAsDag("OutOperandList");
if (DefInit *Init = dynamic_cast<DefInit*>(OutDI->getOperator())) { if (DefInit *Init = dyn_cast<DefInit>(OutDI->getOperator())) {
if (Init->getDef()->getName() != "outs") if (Init->getDef()->getName() != "outs")
throw R->getName() + ": invalid def name for output list: use 'outs'"; throw R->getName() + ": invalid def name for output list: use 'outs'";
} else } else
@ -41,7 +41,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
NumDefs = OutDI->getNumArgs(); NumDefs = OutDI->getNumArgs();
DagInit *InDI = R->getValueAsDag("InOperandList"); DagInit *InDI = R->getValueAsDag("InOperandList");
if (DefInit *Init = dynamic_cast<DefInit*>(InDI->getOperator())) { if (DefInit *Init = dyn_cast<DefInit>(InDI->getOperator())) {
if (Init->getDef()->getName() != "ins") if (Init->getDef()->getName() != "ins")
throw R->getName() + ": invalid def name for input list: use 'ins'"; throw R->getName() + ": invalid def name for input list: use 'ins'";
} else } else
@ -60,7 +60,7 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
ArgName = InDI->getArgName(i-NumDefs); ArgName = InDI->getArgName(i-NumDefs);
} }
DefInit *Arg = dynamic_cast<DefInit*>(ArgInit); DefInit *Arg = dyn_cast<DefInit>(ArgInit);
if (!Arg) if (!Arg)
throw "Illegal operand for the '" + R->getName() + "' instruction!"; throw "Illegal operand for the '" + R->getName() + "' instruction!";
@ -80,8 +80,8 @@ CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
MIOpInfo = Rec->getValueAsDag("MIOperandInfo"); MIOpInfo = Rec->getValueAsDag("MIOperandInfo");
// Verify that MIOpInfo has an 'ops' root value. // Verify that MIOpInfo has an 'ops' root value.
if (!dynamic_cast<DefInit*>(MIOpInfo->getOperator()) || if (!dyn_cast<DefInit>(MIOpInfo->getOperator()) ||
dynamic_cast<DefInit*>(MIOpInfo->getOperator()) dyn_cast<DefInit>(MIOpInfo->getOperator())
->getDef()->getName() != "ops") ->getDef()->getName() != "ops")
throw "Bad value for MIOperandInfo in operand '" + Rec->getName() + throw "Bad value for MIOperandInfo in operand '" + Rec->getName() +
"'\n"; "'\n";
@ -416,7 +416,7 @@ bool CodeGenInstAlias::tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo,
ArrayRef<SMLoc> Loc, CodeGenTarget &T, ArrayRef<SMLoc> Loc, CodeGenTarget &T,
ResultOperand &ResOp) { ResultOperand &ResOp) {
Init *Arg = Result->getArg(AliasOpNo); Init *Arg = Result->getArg(AliasOpNo);
DefInit *ADI = dynamic_cast<DefInit*>(Arg); DefInit *ADI = dyn_cast<DefInit>(Arg);
if (ADI && ADI->getDef() == InstOpRec) { if (ADI && ADI->getDef() == InstOpRec) {
// If the operand is a record, it must have a name, and the record type // If the operand is a record, it must have a name, and the record type
@ -446,7 +446,7 @@ bool CodeGenInstAlias::tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo,
DagInit *DI = InstOpRec->getValueAsDag("MIOperandInfo"); DagInit *DI = InstOpRec->getValueAsDag("MIOperandInfo");
// The operand info should only have a single (register) entry. We // The operand info should only have a single (register) entry. We
// want the register class of it. // want the register class of it.
InstOpRec = dynamic_cast<DefInit*>(DI->getArg(0))->getDef(); InstOpRec = dyn_cast<DefInit>(DI->getArg(0))->getDef();
} }
if (InstOpRec->isSubClassOf("RegisterOperand")) if (InstOpRec->isSubClassOf("RegisterOperand"))
@ -486,7 +486,7 @@ bool CodeGenInstAlias::tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo,
} }
// Literal integers. // Literal integers.
if (IntInit *II = dynamic_cast<IntInit*>(Arg)) { if (IntInit *II = dyn_cast<IntInit>(Arg)) {
if (hasSubOps || !InstOpRec->isSubClassOf("Operand")) if (hasSubOps || !InstOpRec->isSubClassOf("Operand"))
return false; return false;
// Integer arguments can't have names. // Integer arguments can't have names.
@ -518,7 +518,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
Result = R->getValueAsDag("ResultInst"); Result = R->getValueAsDag("ResultInst");
// Verify that the root of the result is an instruction. // Verify that the root of the result is an instruction.
DefInit *DI = dynamic_cast<DefInit*>(Result->getOperator()); DefInit *DI = dyn_cast<DefInit>(Result->getOperator());
if (DI == 0 || !DI->getDef()->isSubClassOf("Instruction")) if (DI == 0 || !DI->getDef()->isSubClassOf("Instruction"))
throw TGError(R->getLoc(), "result of inst alias should be an instruction"); throw TGError(R->getLoc(), "result of inst alias should be an instruction");
@ -528,7 +528,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
// the same class. // the same class.
StringMap<Record*> NameClass; StringMap<Record*> NameClass;
for (unsigned i = 0, e = Result->getNumArgs(); i != e; ++i) { for (unsigned i = 0, e = Result->getNumArgs(); i != e; ++i) {
DefInit *ADI = dynamic_cast<DefInit*>(Result->getArg(i)); DefInit *ADI = dyn_cast<DefInit>(Result->getArg(i));
if (!ADI || Result->getArgName(i).empty()) if (!ADI || Result->getArgName(i).empty())
continue; continue;
// Verify we don't have something like: (someinst GR16:$foo, GR32:$foo) // Verify we don't have something like: (someinst GR16:$foo, GR32:$foo)
@ -575,7 +575,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
} else { } else {
DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo; DagInit *MIOI = ResultInst->Operands[i].MIOperandInfo;
for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) { for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) {
Record *SubRec = dynamic_cast<DefInit*>(MIOI->getArg(SubOp))->getDef(); Record *SubRec = dyn_cast<DefInit>(MIOI->getArg(SubOp))->getDef();
// Take care to instantiate each of the suboperands with the correct // Take care to instantiate each of the suboperands with the correct
// nomenclature: $foo.bar // nomenclature: $foo.bar
@ -596,7 +596,7 @@ CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) { for (unsigned SubOp = 0; SubOp != NumSubOps; ++SubOp) {
if (AliasOpNo >= Result->getNumArgs()) if (AliasOpNo >= Result->getNumArgs())
throw TGError(R->getLoc(), "not enough arguments for instruction!"); throw TGError(R->getLoc(), "not enough arguments for instruction!");
Record *SubRec = dynamic_cast<DefInit*>(MIOI->getArg(SubOp))->getDef(); Record *SubRec = dyn_cast<DefInit>(MIOI->getArg(SubOp))->getDef();
if (tryAliasOpMatch(Result, AliasOpNo, SubRec, false, if (tryAliasOpMatch(Result, AliasOpNo, SubRec, false,
R->getLoc(), T, ResOp)) { R->getLoc(), T, ResOp)) {
ResultOperands.push_back(ResOp); ResultOperands.push_back(ResOp);

2
llvm/utils/TableGen/CodeGenSchedule.cpp
View File

@ -59,7 +59,7 @@ struct InstRegexOp : public SetTheory::Operator {
SmallVector<Regex*, 4> RegexList; SmallVector<Regex*, 4> RegexList;
for (DagInit::const_arg_iterator for (DagInit::const_arg_iterator
AI = Expr->arg_begin(), AE = Expr->arg_end(); AI != AE; ++AI) { AI = Expr->arg_begin(), AE = Expr->arg_end(); AI != AE; ++AI) {
StringInit *SI = dynamic_cast<StringInit*>(*AI); StringInit *SI = dyn_cast<StringInit>(*AI);
if (!SI) if (!SI)
throw "instregex requires pattern string: " + Expr->getAsString(); throw "instregex requires pattern string: " + Expr->getAsString();
std::string pat = SI->getValue(); std::string pat = SI->getValue();

10
llvm/utils/TableGen/DAGISelMatcherGen.cpp
View File

@ -203,7 +203,7 @@ void MatcherGen::EmitLeafMatchCode(const TreePatternNode *N) {
assert(N->isLeaf() && "Not a leaf?"); assert(N->isLeaf() && "Not a leaf?");
// Direct match against an integer constant. // Direct match against an integer constant.
if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) { if (IntInit *II = dyn_cast<IntInit>(N->getLeafValue())) {
// If this is the root of the dag we're matching, we emit a redundant opcode // 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 // check to ensure that this gets folded into the normal top-level
// OpcodeSwitch. // OpcodeSwitch.
@ -215,7 +215,7 @@ void MatcherGen::EmitLeafMatchCode(const TreePatternNode *N) {
return AddMatcher(new CheckIntegerMatcher(II->getValue())); return AddMatcher(new CheckIntegerMatcher(II->getValue()));
} }
DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue()); DefInit *DI = dyn_cast<DefInit>(N->getLeafValue());
if (DI == 0) { if (DI == 0) {
errs() << "Unknown leaf kind: " << *N << "\n"; errs() << "Unknown leaf kind: " << *N << "\n";
abort(); abort();
@ -283,7 +283,7 @@ void MatcherGen::EmitOperatorMatchCode(const TreePatternNode *N,
N->getOperator()->getName() == "or") && N->getOperator()->getName() == "or") &&
N->getChild(1)->isLeaf() && N->getChild(1)->getPredicateFns().empty() && N->getChild(1)->isLeaf() && N->getChild(1)->getPredicateFns().empty() &&
N->getPredicateFns().empty()) { N->getPredicateFns().empty()) {
if (IntInit *II = dynamic_cast<IntInit*>(N->getChild(1)->getLeafValue())) { if (IntInit *II = dyn_cast<IntInit>(N->getChild(1)->getLeafValue())) {
if (!isPowerOf2_32(II->getValue())) { // Don't bother with single bits. if (!isPowerOf2_32(II->getValue())) { // Don't bother with single bits.
// If this is at the root of the pattern, we emit a redundant // If this is at the root of the pattern, we emit a redundant
// CheckOpcode so that the following checks get factored properly under // CheckOpcode so that the following checks get factored properly under
@ -572,14 +572,14 @@ void MatcherGen::EmitResultLeafAsOperand(const TreePatternNode *N,
SmallVectorImpl<unsigned> &ResultOps) { SmallVectorImpl<unsigned> &ResultOps) {
assert(N->isLeaf() && "Must be a leaf"); assert(N->isLeaf() && "Must be a leaf");
if (IntInit *II = dynamic_cast<IntInit*>(N->getLeafValue())) { if (IntInit *II = dyn_cast<IntInit>(N->getLeafValue())) {
AddMatcher(new EmitIntegerMatcher(II->getValue(), N->getType(0))); AddMatcher(new EmitIntegerMatcher(II->getValue(), N->getType(0)));
ResultOps.push_back(NextRecordedOperandNo++); ResultOps.push_back(NextRecordedOperandNo++);
return; return;
} }
// If this is an explicit register reference, handle it. // If this is an explicit register reference, handle it.
if (DefInit *DI = dynamic_cast<DefInit*>(N->getLeafValue())) { if (DefInit *DI = dyn_cast<DefInit>(N->getLeafValue())) {
Record *Def = DI->getDef(); Record *Def = DI->getDef();
if (Def->isSubClassOf("Register")) { if (Def->isSubClassOf("Register")) {
const CodeGenRegister *Reg = const CodeGenRegister *Reg =

6
llvm/utils/TableGen/FastISelEmitter.cpp
View File

@ -245,7 +245,7 @@ struct OperandsSignature {
if (Op->getType(0) != VT) if (Op->getType(0) != VT)
return false; return false;
DefInit *OpDI = dynamic_cast<DefInit*>(Op->getLeafValue()); DefInit *OpDI = dyn_cast<DefInit>(Op->getLeafValue());
if (!OpDI) if (!OpDI)
return false; return false;
Record *OpLeafRec = OpDI->getDef(); Record *OpLeafRec = OpDI->getDef();
@ -406,7 +406,7 @@ static std::string PhyRegForNode(TreePatternNode *Op,
if (!Op->isLeaf()) if (!Op->isLeaf())
return PhysReg; return PhysReg;
DefInit *OpDI = dynamic_cast<DefInit*>(Op->getLeafValue()); DefInit *OpDI = dyn_cast<DefInit>(Op->getLeafValue());
Record *OpLeafRec = OpDI->getDef(); Record *OpLeafRec = OpDI->getDef();
if (!OpLeafRec->isSubClassOf("Register")) if (!OpLeafRec->isSubClassOf("Register"))
return PhysReg; return PhysReg;
@ -473,7 +473,7 @@ void FastISelMap::collectPatterns(CodeGenDAGPatterns &CGP) {
// a bit too complicated for now. // a bit too complicated for now.
if (!Dst->getChild(1)->isLeaf()) continue; if (!Dst->getChild(1)->isLeaf()) continue;
DefInit *SR = dynamic_cast<DefInit*>(Dst->getChild(1)->getLeafValue()); DefInit *SR = dyn_cast<DefInit>(Dst->getChild(1)->getLeafValue());
if (SR) if (SR)
SubRegNo = getQualifiedName(SR->getDef()); SubRegNo = getQualifiedName(SR->getDef());
else else

12
llvm/utils/TableGen/FixedLenDecoderEmitter.cpp
View File

@ -142,7 +142,7 @@ static int Value(bit_value_t V) {
return ValueNotSet(V) ? -1 : (V == BIT_FALSE ? 0 : 1); return ValueNotSet(V) ? -1 : (V == BIT_FALSE ? 0 : 1);
} }
static bit_value_t bitFromBits(const BitsInit &bits, unsigned index) { static bit_value_t bitFromBits(const BitsInit &bits, unsigned index) {
if (BitInit *bit = dynamic_cast<BitInit*>(bits.getBit(index))) if (BitInit *bit = dyn_cast<BitInit>(bits.getBit(index)))
return bit->getValue() ? BIT_TRUE : BIT_FALSE; return bit->getValue() ? BIT_TRUE : BIT_FALSE;
// The bit is uninitialized. // The bit is uninitialized.
@ -1757,7 +1757,7 @@ static bool populateInstruction(const CodeGenInstruction &CGI, unsigned Opc,
// for decoding register classes. // for decoding register classes.
// FIXME: This need to be extended to handle instructions with custom // FIXME: This need to be extended to handle instructions with custom
// decoder methods, and operands with (simple) MIOperandInfo's. // decoder methods, and operands with (simple) MIOperandInfo's.
TypedInit *TI = dynamic_cast<TypedInit*>(NI->first); TypedInit *TI = dyn_cast<TypedInit>(NI->first);
RecordRecTy *Type = dyn_cast<RecordRecTy>(TI->getType()); RecordRecTy *Type = dyn_cast<RecordRecTy>(TI->getType());
Record *TypeRecord = Type->getRecord(); Record *TypeRecord = Type->getRecord();
bool isReg = false; bool isReg = false;
@ -1770,7 +1770,7 @@ static bool populateInstruction(const CodeGenInstruction &CGI, unsigned Opc,
RecordVal *DecoderString = TypeRecord->getValue("DecoderMethod"); RecordVal *DecoderString = TypeRecord->getValue("DecoderMethod");
StringInit *String = DecoderString ? StringInit *String = DecoderString ?
dynamic_cast<StringInit*>(DecoderString->getValue()) : 0; dyn_cast<StringInit>(DecoderString->getValue()) : 0;
if (!isReg && String && String->getValue() != "") if (!isReg && String && String->getValue() != "")
Decoder = String->getValue(); Decoder = String->getValue();
@ -1781,11 +1781,11 @@ static bool populateInstruction(const CodeGenInstruction &CGI, unsigned Opc,
for (unsigned bi = 0; bi < Bits.getNumBits(); ++bi) { for (unsigned bi = 0; bi < Bits.getNumBits(); ++bi) {
VarInit *Var = 0; VarInit *Var = 0;
VarBitInit *BI = dynamic_cast<VarBitInit*>(Bits.getBit(bi)); VarBitInit *BI = dyn_cast<VarBitInit>(Bits.getBit(bi));
if (BI) if (BI)
Var = dynamic_cast<VarInit*>(BI->getBitVar()); Var = dyn_cast<VarInit>(BI->getBitVar());
else else
Var = dynamic_cast<VarInit*>(Bits.getBit(bi)); Var = dyn_cast<VarInit>(Bits.getBit(bi));
if (!Var) { if (!Var) {
if (Base != ~0U) { if (Base != ~0U) {

4
llvm/utils/TableGen/InstrInfoEmitter.cpp
View File

@ -89,7 +89,7 @@ InstrInfoEmitter::GetOperandInfo(const CodeGenInstruction &Inst) {
for (unsigned j = 0, e = Inst.Operands[i].MINumOperands; j != e; ++j) { for (unsigned j = 0, e = Inst.Operands[i].MINumOperands; j != e; ++j) {
OperandList.push_back(Inst.Operands[i]); OperandList.push_back(Inst.Operands[i]);
Record *OpR = dynamic_cast<DefInit*>(MIOI->getArg(j))->getDef(); Record *OpR = dyn_cast<DefInit>(MIOI->getArg(j))->getDef();
OperandList.back().Rec = OpR; OperandList.back().Rec = OpR;
} }
} }
@ -345,7 +345,7 @@ void InstrInfoEmitter::emitRecord(const CodeGenInstruction &Inst, unsigned Num,
if (!TSF) throw "no TSFlags?"; if (!TSF) throw "no TSFlags?";
uint64_t Value = 0; uint64_t Value = 0;
for (unsigned i = 0, e = TSF->getNumBits(); i != e; ++i) { for (unsigned i = 0, e = TSF->getNumBits(); i != e; ++i) {
if (BitInit *Bit = dynamic_cast<BitInit*>(TSF->getBit(i))) if (BitInit *Bit = dyn_cast<BitInit>(TSF->getBit(i)))
Value |= uint64_t(Bit->getValue()) << i; Value |= uint64_t(Bit->getValue()) << i;
else else
throw "Invalid TSFlags bit in " + Inst.TheDef->getName(); throw "Invalid TSFlags bit in " + Inst.TheDef->getName();

8
llvm/utils/TableGen/PseudoLoweringEmitter.cpp
View File

@ -74,7 +74,7 @@ addDagOperandMapping(Record *Rec, DagInit *Dag, CodeGenInstruction &Insn,
IndexedMap<OpData> &OperandMap, unsigned BaseIdx) { IndexedMap<OpData> &OperandMap, unsigned BaseIdx) {
unsigned OpsAdded = 0; unsigned OpsAdded = 0;
for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) { for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) {
if (DefInit *DI = dynamic_cast<DefInit*>(Dag->getArg(i))) { if (DefInit *DI = dyn_cast<DefInit>(Dag->getArg(i))) {
// Physical register reference. Explicit check for the special case // Physical register reference. Explicit check for the special case
// "zero_reg" definition. // "zero_reg" definition.
if (DI->getDef()->isSubClassOf("Register") || if (DI->getDef()->isSubClassOf("Register") ||
@ -100,11 +100,11 @@ addDagOperandMapping(Record *Rec, DagInit *Dag, CodeGenInstruction &Insn,
for (unsigned I = 0, E = Insn.Operands[i].MINumOperands; I != E; ++I) for (unsigned I = 0, E = Insn.Operands[i].MINumOperands; I != E; ++I)
OperandMap[BaseIdx + i + I].Kind = OpData::Operand; OperandMap[BaseIdx + i + I].Kind = OpData::Operand;
OpsAdded += Insn.Operands[i].MINumOperands; OpsAdded += Insn.Operands[i].MINumOperands;
} else if (IntInit *II = dynamic_cast<IntInit*>(Dag->getArg(i))) { } else if (IntInit *II = dyn_cast<IntInit>(Dag->getArg(i))) {
OperandMap[BaseIdx + i].Kind = OpData::Imm; OperandMap[BaseIdx + i].Kind = OpData::Imm;
OperandMap[BaseIdx + i].Data.Imm = II->getValue(); OperandMap[BaseIdx + i].Data.Imm = II->getValue();
++OpsAdded; ++OpsAdded;
} else if (DagInit *SubDag = dynamic_cast<DagInit*>(Dag->getArg(i))) { } else if (DagInit *SubDag = dyn_cast<DagInit>(Dag->getArg(i))) {
// Just add the operands recursively. This is almost certainly // Just add the operands recursively. This is almost certainly
// a constant value for a complex operand (> 1 MI operand). // a constant value for a complex operand (> 1 MI operand).
unsigned NewOps = unsigned NewOps =
@ -127,7 +127,7 @@ void PseudoLoweringEmitter::evaluateExpansion(Record *Rec) {
assert(Dag && "Missing result instruction in pseudo expansion!"); assert(Dag && "Missing result instruction in pseudo expansion!");
DEBUG(dbgs() << " Result: " << *Dag << "\n"); DEBUG(dbgs() << " Result: " << *Dag << "\n");
DefInit *OpDef = dynamic_cast<DefInit*>(Dag->getOperator()); DefInit *OpDef = dyn_cast<DefInit>(Dag->getOperator());
if (!OpDef) if (!OpDef)
throw TGError(Rec->getLoc(), Rec->getName() + throw TGError(Rec->getLoc(), Rec->getName() +
" has unexpected operator type!"); " has unexpected operator type!");

4
llvm/utils/TableGen/RegisterInfoEmitter.cpp
View File

@ -325,7 +325,7 @@ RegisterInfoEmitter::EmitRegMappingTables(raw_ostream &OS,
if (!V || !V->getValue()) if (!V || !V->getValue())
continue; continue;
DefInit *DI = dynamic_cast<DefInit*>(V->getValue()); DefInit *DI = dyn_cast<DefInit>(V->getValue());
Record *Alias = DI->getDef(); Record *Alias = DI->getDef();
DwarfRegNums[Reg] = DwarfRegNums[Alias]; DwarfRegNums[Reg] = DwarfRegNums[Alias];
} }
@ -751,7 +751,7 @@ RegisterInfoEmitter::runMCDesc(raw_ostream &OS, CodeGenTarget &Target,
BitsInit *BI = Reg->getValueAsBitsInit("HWEncoding"); BitsInit *BI = Reg->getValueAsBitsInit("HWEncoding");
uint64_t Value = 0; uint64_t Value = 0;
for (unsigned b = 0, be = BI->getNumBits(); b != be; ++b) { for (unsigned b = 0, be = BI->getNumBits(); b != be; ++b) {
if (BitInit *B = dynamic_cast<BitInit*>(BI->getBit(b))) if (BitInit *B = dyn_cast<BitInit>(BI->getBit(b)))
Value |= (uint64_t)B->getValue() << b; Value |= (uint64_t)B->getValue() << b;
} }
OS << " " << Value << ",\n"; OS << " " << Value << ",\n";

22
llvm/utils/TableGen/SetTheory.cpp
View File

@ -72,7 +72,7 @@ struct SetIntBinOp : public SetTheory::Operator {
throw "Operator requires (Op Set, Int) arguments: " + Expr->getAsString(); throw "Operator requires (Op Set, Int) arguments: " + Expr->getAsString();
RecSet Set; RecSet Set;
ST.evaluate(Expr->arg_begin()[0], Set); ST.evaluate(Expr->arg_begin()[0], Set);
IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[1]); IntInit *II = dyn_cast<IntInit>(Expr->arg_begin()[1]);
if (!II) if (!II)
throw "Second argument must be an integer: " + Expr->getAsString(); throw "Second argument must be an integer: " + Expr->getAsString();
apply2(ST, Expr, Set, II->getValue(), Elts); apply2(ST, Expr, Set, II->getValue(), Elts);
@ -165,27 +165,27 @@ struct SequenceOp : public SetTheory::Operator {
throw "Bad args to (sequence \"Format\", From, To): " + throw "Bad args to (sequence \"Format\", From, To): " +
Expr->getAsString(); Expr->getAsString();
else if (Expr->arg_size() == 4) { else if (Expr->arg_size() == 4) {
if (IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[3])) { if (IntInit *II = dyn_cast<IntInit>(Expr->arg_begin()[3])) {
Step = II->getValue(); Step = II->getValue();
} else } else
throw "Stride must be an integer: " + Expr->getAsString(); throw "Stride must be an integer: " + Expr->getAsString();
} }
std::string Format; std::string Format;
if (StringInit *SI = dynamic_cast<StringInit*>(Expr->arg_begin()[0])) if (StringInit *SI = dyn_cast<StringInit>(Expr->arg_begin()[0]))
Format = SI->getValue(); Format = SI->getValue();
else else
throw "Format must be a string: " + Expr->getAsString(); throw "Format must be a string: " + Expr->getAsString();
int64_t From, To; int64_t From, To;
if (IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[1])) if (IntInit *II = dyn_cast<IntInit>(Expr->arg_begin()[1]))
From = II->getValue(); From = II->getValue();
else else
throw "From must be an integer: " + Expr->getAsString(); throw "From must be an integer: " + Expr->getAsString();
if (From < 0 || From >= (1 << 30)) if (From < 0 || From >= (1 << 30))
throw "From out of range"; throw "From out of range";
if (IntInit *II = dynamic_cast<IntInit*>(Expr->arg_begin()[2])) if (IntInit *II = dyn_cast<IntInit>(Expr->arg_begin()[2]))
To = II->getValue(); To = II->getValue();
else else
throw "From must be an integer: " + Expr->getAsString(); throw "From must be an integer: " + Expr->getAsString();
@ -193,7 +193,7 @@ struct SequenceOp : public SetTheory::Operator {
throw "To out of range"; throw "To out of range";
RecordKeeper &Records = RecordKeeper &Records =
dynamic_cast<DefInit&>(*Expr->getOperator()).getDef()->getRecords(); dyn_cast<DefInit>(Expr->getOperator())->getDef()->getRecords();
Step *= From <= To ? 1 : -1; Step *= From <= To ? 1 : -1;
while (true) { while (true) {
@ -261,7 +261,7 @@ void SetTheory::addFieldExpander(StringRef ClassName, StringRef FieldName) {
void SetTheory::evaluate(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. // A def in a list can be a just an element, or it may expand.
if (DefInit *Def = dynamic_cast<DefInit*>(Expr)) { if (DefInit *Def = dyn_cast<DefInit>(Expr)) {
if (const RecVec *Result = expand(Def->getDef())) if (const RecVec *Result = expand(Def->getDef()))
return Elts.insert(Result->begin(), Result->end()); return Elts.insert(Result->begin(), Result->end());
Elts.insert(Def->getDef()); Elts.insert(Def->getDef());
@ -269,14 +269,14 @@ void SetTheory::evaluate(Init *Expr, RecSet &Elts) {
} }
// Lists simply expand. // Lists simply expand.
if (ListInit *LI = dynamic_cast<ListInit*>(Expr)) if (ListInit *LI = dyn_cast<ListInit>(Expr))
return evaluate(LI->begin(), LI->end(), Elts); return evaluate(LI->begin(), LI->end(), Elts);
// Anything else must be a DAG. // Anything else must be a DAG.
DagInit *DagExpr = dynamic_cast<DagInit*>(Expr); DagInit *DagExpr = dyn_cast<DagInit>(Expr);
if (!DagExpr) if (!DagExpr)
throw "Invalid set element: " + Expr->getAsString(); throw "Invalid set element: " + Expr->getAsString();
DefInit *OpInit = dynamic_cast<DefInit*>(DagExpr->getOperator()); DefInit *OpInit = dyn_cast<DefInit>(DagExpr->getOperator());
if (!OpInit) if (!OpInit)
throw "Bad set expression: " + Expr->getAsString(); throw "Bad set expression: " + Expr->getAsString();
Operator *Op = Operators.lookup(OpInit->getDef()->getName()); Operator *Op = Operators.lookup(OpInit->getDef()->getName());
@ -296,7 +296,7 @@ const RecVec *SetTheory::expand(Record *Set) {
const std::vector<Record*> &SC = Set->getSuperClasses(); const std::vector<Record*> &SC = Set->getSuperClasses();
for (unsigned i = 0, e = SC.size(); i != e; ++i) { for (unsigned i = 0, e = SC.size(); i != e; ++i) {
// Skip unnamed superclasses. // Skip unnamed superclasses.
if (!dynamic_cast<const StringInit *>(SC[i]->getNameInit())) if (!dyn_cast<StringInit>(SC[i]->getNameInit()))
continue; continue;
if (Expander *Exp = Expanders.lookup(SC[i]->getName())) { if (Expander *Exp = Expanders.lookup(SC[i]->getName())) {
// This breaks recursive definitions. // This breaks recursive definitions.