72c5a230e5bebb55c6c89745fd385eac713fea81
[oota-llvm.git] / utils / TableGen / Record.cpp
1 //===- Record.cpp - Record implementation ---------------------------------===//
2 //
3 //
4 //===----------------------------------------------------------------------===//
5
6 #include "Record.h"
7
8 //===----------------------------------------------------------------------===//
9 //    Type implementations
10 //===----------------------------------------------------------------------===//
11
12 void RecTy::dump() const { print(std::cerr); }
13
14 Init *BitRecTy::convertValue(BitsInit *BI) {
15   if (BI->getNumBits() != 1) return 0; // Only accept if just one bit!
16   return BI->getBit(0);
17 }
18
19 Init *BitRecTy::convertValue(IntInit *II) {
20   int Val = II->getValue();
21   if (Val != 0 && Val != 1) return 0;  // Only accept 0 or 1 for a bit!
22   
23   return new BitInit(Val != 0); 
24 }
25
26 Init *BitRecTy::convertValue(TypedInit *VI) {
27   if (dynamic_cast<BitRecTy*>(VI->getType()))
28     return VI;  // Accept variable if it is already of bit type!
29   return 0;
30 }
31
32 Init *BitsRecTy::convertValue(UnsetInit *UI) {
33   BitsInit *Ret = new BitsInit(Size);
34
35   for (unsigned i = 0; i != Size; ++i)
36     Ret->setBit(i, new UnsetInit());
37   return Ret;
38 }
39
40 Init *BitsRecTy::convertValue(BitInit *UI) {
41   if (Size != 1) return 0;  // Can only convert single bit...
42   BitsInit *Ret = new BitsInit(1);
43   Ret->setBit(0, UI);
44   return Ret;
45 }
46
47 // convertValue from Int initializer to bits type: Split the integer up into the
48 // appropriate bits...
49 //
50 Init *BitsRecTy::convertValue(IntInit *II) {
51   int Value = II->getValue();
52
53   BitsInit *Ret = new BitsInit(Size);
54   for (unsigned i = 0; i != Size; ++i)
55     Ret->setBit(i, new BitInit(Value & (1 << i)));
56   return Ret;
57 }
58
59 Init *BitsRecTy::convertValue(BitsInit *BI) {
60   // If the number of bits is right, return it.  Otherwise we need to expand or
61   // truncate...
62   if (BI->getNumBits() == Size) return BI;
63   return 0;
64 }
65
66 Init *BitsRecTy::convertValue(TypedInit *VI) {
67   if (BitsRecTy *BRT = dynamic_cast<BitsRecTy*>(VI->getType()))
68     if (BRT->Size == Size) {
69       BitsInit *Ret = new BitsInit(Size);
70       for (unsigned i = 0; i != Size; ++i)
71         Ret->setBit(i, new VarBitInit(VI, i));
72       return Ret;
73     }
74   if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType())) {
75     BitsInit *Ret = new BitsInit(1);
76     Ret->setBit(0, VI);
77     return Ret;
78   }
79       
80   return 0;
81 }
82
83 Init *IntRecTy::convertValue(BitsInit *BI) {
84   int Result = 0;
85   for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) 
86     if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) {
87       Result |= Bit->getValue() << i;
88     } else {
89       return 0;
90     }
91   return new IntInit(Result);
92 }
93
94 Init *IntRecTy::convertValue(TypedInit *TI) {
95   if (dynamic_cast<IntRecTy*>(TI->getType()))
96     return TI;  // Accept variable if already of the right type!
97   return 0;
98 }
99
100 Init *StringRecTy::convertValue(TypedInit *TI) {
101   if (dynamic_cast<StringRecTy*>(TI->getType()))
102     return TI;  // Accept variable if already of the right type!
103   return 0;
104 }
105
106 void ListRecTy::print(std::ostream &OS) const {
107   OS << "list<" << Class->getName() << ">";
108 }
109
110 Init *ListRecTy::convertValue(ListInit *LI) {
111   // Verify that all of the elements of the list are subclasses of the
112   // appopriate class!
113   for (unsigned i = 0, e = LI->getSize(); i != e; ++i)
114     if (!LI->getElement(i)->isSubClassOf(Class))
115       return 0;
116   return LI;
117 }
118
119 void RecordRecTy::print(std::ostream &OS) const {
120   OS << Rec->getName();
121 }
122
123 Init *RecordRecTy::convertValue(DefInit *DI) {
124   // Ensure that DI is a subclass of Rec.
125   if (!DI->getDef()->isSubClassOf(Rec))
126     return 0;
127   return DI;
128 }
129
130 Init *RecordRecTy::convertValue(TypedInit *VI) {
131   // Ensure that VI is compatible with Rec.
132   if (RecordRecTy *RRT = dynamic_cast<RecordRecTy*>(VI->getType()))
133     if (RRT->getRecord()->isSubClassOf(getRecord()) ||
134         RRT->getRecord() == getRecord())
135       return VI;
136   return 0;
137 }
138
139 //===----------------------------------------------------------------------===//
140 //    Initializer implementations
141 //===----------------------------------------------------------------------===//
142
143 void Init::dump() const { return print(std::cerr); }
144
145 Init *BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
146   BitsInit *BI = new BitsInit(Bits.size());
147   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
148     if (Bits[i] >= getNumBits()) {
149       delete BI;
150       return 0;
151     }
152     BI->setBit(i, getBit(Bits[i]));
153   }
154   return BI;
155 }
156
157 void BitsInit::print(std::ostream &OS) const {
158   //if (!printInHex(OS)) return;
159   //if (!printAsVariable(OS)) return;
160   //if (!printAsUnset(OS)) return;
161
162   OS << "{ ";
163   for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
164     if (i) OS << ", ";
165     if (Init *Bit = getBit(e-i-1))
166       Bit->print(OS);
167     else
168       OS << "*";
169   }
170   OS << " }";
171 }
172
173 bool BitsInit::printInHex(std::ostream &OS) const {
174   // First, attempt to convert the value into an integer value...
175   int Result = 0;
176   for (unsigned i = 0, e = getNumBits(); i != e; ++i) 
177     if (BitInit *Bit = dynamic_cast<BitInit*>(getBit(i))) {
178       Result |= Bit->getValue() << i;
179     } else {
180       return true;
181     }
182
183   OS << "0x" << std::hex << Result << std::dec;
184   return false;
185 }
186
187 bool BitsInit::printAsVariable(std::ostream &OS) const {
188   // Get the variable that we may be set equal to...
189   assert(getNumBits() != 0);
190   VarBitInit *FirstBit = dynamic_cast<VarBitInit*>(getBit(0));
191   if (FirstBit == 0) return true;
192   TypedInit *Var = FirstBit->getVariable();
193
194   // Check to make sure the types are compatible.
195   BitsRecTy *Ty = dynamic_cast<BitsRecTy*>(FirstBit->getVariable()->getType());
196   if (Ty == 0) return true;
197   if (Ty->getNumBits() != getNumBits()) return true; // Incompatible types!
198
199   // Check to make sure all bits are referring to the right bits in the variable
200   for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
201     VarBitInit *Bit = dynamic_cast<VarBitInit*>(getBit(i));
202     if (Bit == 0 || Bit->getVariable() != Var || Bit->getBitNum() != i)
203       return true;
204   }
205
206   Var->print(OS);
207   return false;
208 }
209
210 bool BitsInit::printAsUnset(std::ostream &OS) const {
211   for (unsigned i = 0, e = getNumBits(); i != e; ++i) 
212     if (!dynamic_cast<UnsetInit*>(getBit(i)))
213       return true;
214   OS << "?";
215   return false;
216 }
217
218 // resolveReferences - If there are any field references that refer to fields
219 // that have been filled in, we can propagate the values now.
220 //
221 Init *BitsInit::resolveReferences(Record &R) {
222   bool Changed = false;
223   BitsInit *New = new BitsInit(getNumBits());
224
225   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
226     Init *B;
227     Init *CurBit = getBit(i);
228
229     do {
230       B = CurBit;
231       CurBit = CurBit->resolveReferences(R);
232       Changed |= B != CurBit;
233     } while (B != CurBit);
234     New->setBit(i, CurBit);
235   }
236
237   if (Changed)
238     return New;
239   delete New;
240   return this;
241 }
242
243 Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
244   BitsInit *BI = new BitsInit(Bits.size());
245
246   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
247     if (Bits[i] >= 32) {
248       delete BI;
249       return 0;
250     }
251     BI->setBit(i, new BitInit(Value & (1 << Bits[i])));
252   }
253   return BI;
254 }
255
256 void ListInit::print(std::ostream &OS) const {
257   OS << "[";
258   for (unsigned i = 0, e = Records.size(); i != e; ++i) {
259     if (i) OS << ", ";
260     OS << Records[i]->getName();
261   }
262   OS << "]";
263 }
264
265 Init *VarInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
266   BitsRecTy *T = dynamic_cast<BitsRecTy*>(getType());
267   if (T == 0) return 0;  // Cannot subscript a non-bits variable...
268   unsigned NumBits = T->getNumBits();
269
270   BitsInit *BI = new BitsInit(Bits.size());
271   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
272     if (Bits[i] >= NumBits) {
273       delete BI;
274       return 0;
275     }
276     BI->setBit(i, new VarBitInit(this, Bits[i]));
277   }
278   return BI;
279 }
280
281 Init *VarInit::resolveBitReference(Record &R, unsigned Bit) {
282   if (R.isTemplateArg(getName()))
283     return this;
284
285   RecordVal *RV = R.getValue(getName());
286   assert(RV && "Reference to a non-existant variable?");
287   assert(dynamic_cast<BitsInit*>(RV->getValue()));
288   BitsInit *BI = (BitsInit*)RV->getValue();
289   
290   assert(Bit < BI->getNumBits() && "Bit reference out of range!");
291   Init *B = BI->getBit(Bit);
292
293   if (!dynamic_cast<UnsetInit*>(B))  // If the bit is not set...
294     return B;                        // Replace the VarBitInit with it.
295   return this;
296 }
297
298 RecTy *VarInit::getFieldType(const std::string &FieldName) const {
299   if (RecordRecTy *RTy = dynamic_cast<RecordRecTy*>(getType()))
300     if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName))
301       return RV->getType();
302   return 0;
303 }
304
305 Init *VarInit::getFieldInit(Record &R, const std::string &FieldName) const {
306   if (RecordRecTy *RTy = dynamic_cast<RecordRecTy*>(getType()))
307     if (const RecordVal *RV = R.getValue(VarName))
308       if (Init *I = RV->getValue()->getFieldInit(R, FieldName))
309         return I;
310       else
311         return (Init*)this;
312   return 0;
313 }
314
315 /// resolveReferences - This method is used by classes that refer to other
316 /// variables which may not be defined at the time they expression is formed.
317 /// If a value is set for the variable later, this method will be called on
318 /// users of the value to allow the value to propagate out.
319 ///
320 Init *VarInit::resolveReferences(Record &R) {
321   if (RecordVal *Val = R.getValue(VarName))
322     if (!dynamic_cast<UnsetInit*>(Val->getValue()))
323       return Val->getValue();
324   return this;
325 }
326   
327
328 Init *VarBitInit::resolveReferences(Record &R) {
329   Init *I = getVariable()->resolveBitReference(R, getBitNum());
330   if (I != getVariable())
331     return I;
332   return this;
333 }
334
335 RecTy *DefInit::getFieldType(const std::string &FieldName) const {
336   if (const RecordVal *RV = Def->getValue(FieldName))
337     return RV->getType();
338   return 0;
339 }
340
341 Init *DefInit::getFieldInit(Record &R, const std::string &FieldName) const {
342   return Def->getValue(FieldName)->getValue();
343 }
344
345
346 void DefInit::print(std::ostream &OS) const {
347   OS << Def->getName();
348 }
349
350 Init *FieldInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
351   BitsRecTy *T = dynamic_cast<BitsRecTy*>(getType());
352   if (T == 0) return 0;  // Cannot subscript a non-bits field...
353   unsigned NumBits = T->getNumBits();
354
355   BitsInit *BI = new BitsInit(Bits.size());
356   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
357     if (Bits[i] >= NumBits) {
358       delete BI;
359       return 0;
360     }
361     BI->setBit(i, new VarBitInit(this, Bits[i]));
362   }
363   return BI;
364 }
365
366 Init *FieldInit::resolveBitReference(Record &R, unsigned Bit) {
367   Init *BitsVal = Rec->getFieldInit(R, FieldName);
368   assert(BitsVal && "No initializer found!");
369
370   if (BitsInit *BI = dynamic_cast<BitsInit*>(BitsVal)) {
371     assert(Bit < BI->getNumBits() && "Bit reference out of range!");
372     Init *B = BI->getBit(Bit);
373     
374     if (dynamic_cast<BitInit*>(B))  // If the bit is set...
375       return B;                     // Replace the VarBitInit with it.
376   }
377   return this;
378 }
379
380
381 //===----------------------------------------------------------------------===//
382 //    Other implementations
383 //===----------------------------------------------------------------------===//
384
385 RecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P)
386   : Name(N), Ty(T), Prefix(P) {
387   Value = Ty->convertValue(new UnsetInit());
388   assert(Value && "Cannot create unset value for current type!");
389 }
390
391 void RecordVal::dump() const { std::cerr << *this; }
392
393 void RecordVal::print(std::ostream &OS, bool PrintSem) const {
394   if (getPrefix()) OS << "field ";
395   OS << *getType() << " " << getName();
396   if (getValue()) {
397     OS << " = " << *getValue();
398   }
399   if (PrintSem) OS << ";\n";
400 }
401
402 // resolveReferences - If there are any field references that refer to fields
403 // that have been filled in, we can propagate the values now.
404 //
405 void Record::resolveReferences() {
406   for (unsigned i = 0, e = Values.size(); i != e; ++i)
407     Values[i].setValue(Values[i].getValue()->resolveReferences(*this));
408 }
409
410 void Record::dump() const { std::cerr << *this; }
411
412 std::ostream &operator<<(std::ostream &OS, const Record &R) {
413   OS << R.getName();
414
415   const std::vector<std::string> &TArgs = R.getTemplateArgs();
416   if (!TArgs.empty()) {
417     OS << "<";
418     for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
419       if (i) OS << ", ";
420       const RecordVal *RV = R.getValue(TArgs[i]);
421       assert(RV && "Template argument record not found??");
422       RV->print(OS, false);
423     }
424     OS << ">";
425   }
426
427   OS << " {";
428   const std::vector<Record*> &SC = R.getSuperClasses();
429   if (!SC.empty()) {
430     OS << "\t//";
431     for (unsigned i = 0, e = SC.size(); i != e; ++i)
432       OS << " " << SC[i]->getName();
433   }
434   OS << "\n";
435
436   const std::vector<RecordVal> &Vals = R.getValues();
437   for (unsigned i = 0, e = Vals.size(); i != e; ++i)
438     if (Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName()))
439       OS << Vals[i];
440   for (unsigned i = 0, e = Vals.size(); i != e; ++i)
441     if (!Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName()))
442       OS << Vals[i];
443
444   return OS << "}\n";
445 }
446
447 void RecordKeeper::dump() const { std::cerr << *this; }
448
449 std::ostream &operator<<(std::ostream &OS, const RecordKeeper &RK) {
450   OS << "------------- Classes -----------------\n";
451   const std::map<std::string, Record*> &Classes = RK.getClasses();
452   for (std::map<std::string, Record*>::const_iterator I = Classes.begin(),
453          E = Classes.end(); I != E; ++I)
454     OS << "class " << *I->second;
455   
456   OS << "------------- Defs -----------------\n";
457   const std::map<std::string, Record*> &Defs = RK.getDefs();
458   for (std::map<std::string, Record*>::const_iterator I = Defs.begin(),
459          E = Defs.end(); I != E; ++I)
460     OS << "def " << *I->second;
461   return OS;
462 }