[AVX] Remove Mutating Members from Inits

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

utils/TableGen/CodeEmitterGen.cpp

@@ -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);
+      NewBits[bit]        = BitSwap;
-      NewBI->setBit(bitSwapIdx, OrigBit);
+      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);

utils/TableGen/Record.cpp

@@ -15,6 +15,8 @@
 #include "Error.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/Format.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 
 using namespace llvm;
@@ -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());
+    NewBits[i] = new UnsetInit();
-  return Ret;
+
+  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);
+  return new BitsInit(ArrayRef<Init *>(UI));
-  Ret->setBit(0, UI);
-  return Ret;
 }
 
 /// 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);
+  SmallVector<Init *, 16> NewBits(Size);
-  for (unsigned i = 0; i != Size; ++i)
-    Ret->setBit(i, new BitInit(Value & (1LL << i)));
 
-  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));
+        NewBits[i] = new VarBitInit(VI, i);
-      return Ret;
+      return new BitsInit(ArrayRef<Init *>(NewBits));
     }
 
-  if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType())) {
+  if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType()))
-    BitsInit *Ret = new BitsInit(1);
+    return new BitsInit(VI);
-    Ret->setBit(0, VI);
-    return Ret;
-  }
 
   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,
+            NewBits[i] =
-                                          new IntInit((MHSVal & (1LL << i)) ? 1 : 0),
+              new TernOpInit(TernOpInit::IF, LHS,
-                                          new IntInit((RHSVal & (1LL << i)) ? 1 : 0),
+                             new IntInit((MHSVal & (1LL << i)) ? 1 : 0),
-                                          VI->getType()));
+                             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,
+            NewBits[i] = new TernOpInit(TernOpInit::IF, LHS,
-                                          MHSbs->getBit(i),
+                                        MHSbs->getBit(i),
-                                          RHSbs->getBit(i),
+                                        RHSbs->getBit(i),
-                                          VI->getType()));
+                                        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()) {
+    if (Bits[i] >= getNumBits())
-      delete BI;
       return 0;
-    }
+    NewBits[i] = getBit(Bits[i]);
-    BI->setBit(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;
+    return new BitsInit(ArrayRef<Init *>(NewBits));
-  delete New;
+
   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) {
+    if (Bits[i] >= 64)
-      delete BI;
       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) {
+    if (Bits[i] >= NumBits)
-      delete BI;
       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) {

utils/TableGen/Record.h

@@ -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;

utils/TableGen/TGParser.cpp

@@ -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)
+      if (NewBits[i] == 0)
-        NewVal->setBit(i, CurVal->getBit(i));
+        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 '['