RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-02-28 22:58:17 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[AVX] Remove Mutating Members from Inits

Browse Source 
Get rid of all Init members that modify internal state.  This is in
preparation for making references to Inits const.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@136483 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
David Greene 2011-07-29 19:07:00 +00:00
parent c45a2cacd0
commit ca7fd3de36
4 changed files with 69 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
utils/TableGen/CodeEmitterGen.cpp
View File

@ -41,19 +41,23 @@ void CodeEmitterGen::reverseBits(std::vector<Record*> &Insts) {
BitsInit *BI = R->getValueAsBitsInit("Inst");
unsigned numBits = BI->getNumBits();
BitsInit *NewBI = new BitsInit(numBits);
SmallVector<Init *, 16> NewBits(numBits);
for (unsigned bit = 0, end = numBits / 2; bit != end; ++bit) {
unsigned bitSwapIdx = numBits - bit - 1;
Init *OrigBit = BI->getBit(bit);
Init *BitSwap = BI->getBit(bitSwapIdx);
NewBI->setBit(bit, BitSwap);
NewBI->setBit(bitSwapIdx, OrigBit);
NewBits[bit] = BitSwap;
NewBits[bitSwapIdx] = OrigBit;
}
if (numBits % 2) {
unsigned middle = (numBits + 1) / 2;
NewBI->setBit(middle, BI->getBit(middle));
NewBits[middle] = BI->getBit(middle);
}
BitsInit *NewBI = new BitsInit(ArrayRef<Init *>(NewBits));
// Update the bits in reversed order so that emitInstrOpBits will get the
// correct endianness.
R->getValue("Inst")->setValue(NewBI);

102
utils/TableGen/Record.cpp
View File

@ -15,6 +15,8 @@
#include "Error.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Format.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringExtras.h"
using namespace llvm;
@ -120,18 +122,17 @@ std::string BitsRecTy::getAsString() const {
}
Init *BitsRecTy::convertValue(UnsetInit *UI) {
BitsInit *Ret = new BitsInit(Size);
SmallVector<Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
Ret->setBit(i, new UnsetInit());
return Ret;
NewBits[i] = new UnsetInit();
return new BitsInit(ArrayRef<Init *>(NewBits));
}
Init *BitsRecTy::convertValue(BitInit *UI) {
if (Size != 1) return 0; // Can only convert single bit.
BitsInit *Ret = new BitsInit(1);
Ret->setBit(0, UI);
return Ret;
return new BitsInit(ArrayRef<Init *>(UI));
}
/// canFitInBitfield - Return true if the number of bits is large enough to hold
@ -151,11 +152,12 @@ Init *BitsRecTy::convertValue(IntInit *II) {
if (!canFitInBitfield(Value, Size))
return 0;
BitsInit *Ret = new BitsInit(Size);
for (unsigned i = 0; i != Size; ++i)
Ret->setBit(i, new BitInit(Value & (1LL << i)));
SmallVector<Init *, 16> NewBits(Size);
return Ret;
for (unsigned i = 0; i != Size; ++i)
NewBits[i] = new BitInit(Value & (1LL << i));
return new BitsInit(ArrayRef<Init *>(NewBits));
}
Init *BitsRecTy::convertValue(BitsInit *BI) {
@ -168,17 +170,15 @@ Init *BitsRecTy::convertValue(BitsInit *BI) {
Init *BitsRecTy::convertValue(TypedInit *VI) {
if (BitsRecTy *BRT = dynamic_cast<BitsRecTy*>(VI->getType()))
if (BRT->Size == Size) {
BitsInit *Ret = new BitsInit(Size);
SmallVector<Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
Ret->setBit(i, new VarBitInit(VI, i));
return Ret;
NewBits[i] = new VarBitInit(VI, i);
return new BitsInit(ArrayRef<Init *>(NewBits));
}
if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType())) {
BitsInit *Ret = new BitsInit(1);
Ret->setBit(0, VI);
return Ret;
}
if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType()))
return new BitsInit(VI);
if (TernOpInit *Tern = dynamic_cast<TernOpInit*>(VI)) {
if (Tern->getOpcode() == TernOpInit::IF) {
@ -194,30 +194,31 @@ Init *BitsRecTy::convertValue(TypedInit *VI) {
int64_t RHSVal = RHSi->getValue();
if (canFitInBitfield(MHSVal, Size) && canFitInBitfield(RHSVal, Size)) {
BitsInit *Ret = new BitsInit(Size);
SmallVector<Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
Ret->setBit(i, new TernOpInit(TernOpInit::IF, LHS,
new IntInit((MHSVal & (1LL << i)) ? 1 : 0),
new IntInit((RHSVal & (1LL << i)) ? 1 : 0),
VI->getType()));
NewBits[i] =
new TernOpInit(TernOpInit::IF, LHS,
new IntInit((MHSVal & (1LL << i)) ? 1 : 0),
new IntInit((RHSVal & (1LL << i)) ? 1 : 0),
VI->getType());
return Ret;
return new BitsInit(ArrayRef<Init *>(NewBits));
}
} else {
BitsInit *MHSbs = dynamic_cast<BitsInit*>(MHS);
BitsInit *RHSbs = dynamic_cast<BitsInit*>(RHS);
if (MHSbs && RHSbs) {
BitsInit *Ret = new BitsInit(Size);
SmallVector<Init *, 16> NewBits(Size);
for (unsigned i = 0; i != Size; ++i)
Ret->setBit(i, new TernOpInit(TernOpInit::IF, LHS,
MHSbs->getBit(i),
RHSbs->getBit(i),
VI->getType()));
NewBits[i] = new TernOpInit(TernOpInit::IF, LHS,
MHSbs->getBit(i),
RHSbs->getBit(i),
VI->getType());
return Ret;
return new BitsInit(ArrayRef<Init *>(NewBits));
}
}
}
@ -442,15 +443,14 @@ RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
void Init::dump() const { return print(errs()); }
Init *BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
BitsInit *BI = new BitsInit(Bits.size());
SmallVector<Init *, 16> NewBits(Bits.size());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= getNumBits()) {
delete BI;
if (Bits[i] >= getNumBits())
return 0;
}
BI->setBit(i, getBit(Bits[i]));
NewBits[i] = getBit(Bits[i]);
}
return BI;
return new BitsInit(ArrayRef<Init *>(NewBits));
}
std::string BitsInit::getAsString() const {
@ -470,7 +470,7 @@ std::string BitsInit::getAsString() const {
//
Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) {
bool Changed = false;
BitsInit *New = new BitsInit(getNumBits());
SmallVector<Init *, 16> NewBits(getNumBits());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
Init *B;
@ -481,12 +481,12 @@ Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) {
CurBit = CurBit->resolveReferences(R, RV);
Changed |= B != CurBit;
} while (B != CurBit);
New->setBit(i, CurBit);
NewBits[i] = CurBit;
}
if (Changed)
return New;
delete New;
return new BitsInit(ArrayRef<Init *>(NewBits));
return this;
}
@ -495,16 +495,15 @@ std::string IntInit::getAsString() const {
}
Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
BitsInit *BI = new BitsInit(Bits.size());
SmallVector<Init *, 16> NewBits(Bits.size());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= 64) {
delete BI;
if (Bits[i] >= 64)
return 0;
}
BI->setBit(i, new BitInit(Value & (INT64_C(1) << Bits[i])));
NewBits[i] = new BitInit(Value & (INT64_C(1) << Bits[i]));
}
return BI;
return new BitsInit(ArrayRef<Init *>(NewBits));
}
Init *ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
@ -1085,15 +1084,14 @@ Init *TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
if (T == 0) return 0; // Cannot subscript a non-bits variable.
unsigned NumBits = T->getNumBits();
BitsInit *BI = new BitsInit(Bits.size());
SmallVector<Init *, 16> NewBits(Bits.size());
for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
if (Bits[i] >= NumBits) {
delete BI;
if (Bits[i] >= NumBits)
return 0;
}
BI->setBit(i, new VarBitInit(this, Bits[i]));
NewBits[i] = new VarBitInit(this, Bits[i]);
}
return BI;
return new BitsInit(ArrayRef<Init *>(NewBits));
}
Init *TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) {

11
utils/TableGen/Record.h
View File

@ -625,6 +625,7 @@ class BitsInit : public Init {
std::vector<Init*> Bits;
public:
explicit BitsInit(unsigned Size) : Bits(Size) {}
BitsInit(ArrayRef<Init *> Range) : Bits(Range.begin(), Range.end()) {}
unsigned getNumBits() const { return Bits.size(); }
@ -632,11 +633,6 @@ public:
assert(Bit < Bits.size() && "Bit index out of range!");
return Bits[Bit];
}
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 Init *convertInitializerTo(RecTy *Ty) {
return Ty->convertValue(this);
@ -1177,11 +1173,6 @@ public:
return ArgNames[Num];
}
void setArg(unsigned Num, Init *I) {
assert(Num < Args.size() && "Arg number out of range!");
Args[Num] = I;
}
virtual Init *resolveReferences(Record &R, const RecordVal *RV);
virtual std::string getAsString() const;

19
utils/TableGen/TGParser.cpp
View File

@ -116,22 +116,22 @@ bool TGParser::SetValue(Record *CurRec, SMLoc Loc, const std::string &ValName,
BitsInit *BInit = dynamic_cast<BitsInit*>(BI);
assert(BInit != 0);
BitsInit *NewVal = new BitsInit(CurVal->getNumBits());
SmallVector<Init *, 16> NewBits(CurVal->getNumBits());
// Loop over bits, assigning values as appropriate.
for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
unsigned Bit = BitList[i];
if (NewVal->getBit(Bit))
if (NewBits[Bit])
return Error(Loc, "Cannot set bit #" + utostr(Bit) + " of value '" +
ValName + "' more than once");
NewVal->setBit(Bit, BInit->getBit(i));
NewBits[Bit] = BInit->getBit(i);
}
for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
if (NewVal->getBit(i) == 0)
NewVal->setBit(i, CurVal->getBit(i));
if (NewBits[i] == 0)
NewBits[i] = CurVal->getBit(i);
V = NewVal;
V = new BitsInit(ArrayRef<Init *>(NewBits));
}
if (RV->setValue(V))
@ -1127,7 +1127,8 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
}
Lex.Lex(); // eat the '}'
BitsInit *Result = new BitsInit(Vals.size());
SmallVector<Init *, 16> NewBits(Vals.size());
for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
Init *Bit = Vals[i]->convertInitializerTo(BitRecTy::get());
if (Bit == 0) {
@ -1135,9 +1136,9 @@ Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType) {
") is not convertable to a bit");
return 0;
}
Result->setBit(Vals.size()-i-1, Bit);
NewBits[Vals.size()-i-1] = Bit;
}
return Result;
return new BitsInit(ArrayRef<Init *>(NewBits));
}
case tgtok::l_square: { // Value ::= '[' ValueList ']'
Lex.Lex(); // eat the '['