← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/utils/TableGen/Record.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/utils/TableGen/Record.cpp
 
1
//===- Record.cpp - Record implementation ---------------------------------===//
 
2
//
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is distributed under the University of Illinois Open Source
 
6
// License. See LICENSE.TXT for details.
 
7
//
 
8
//===----------------------------------------------------------------------===//
 
9
//
 
10
// Implement the tablegen record classes.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#include "Record.h"
 
15
#include "llvm/System/DataTypes.h"
 
16
#include "llvm/Support/Format.h"
 
17
#include "llvm/ADT/StringExtras.h"
 
18
 
 
19
using namespace llvm;
 
20
 
 
21
//===----------------------------------------------------------------------===//
 
22
//    Type implementations
 
23
//===----------------------------------------------------------------------===//
 
24
 
 
25
void RecTy::dump() const { print(errs()); }
 
26
 
 
27
Init *BitRecTy::convertValue(BitsInit *BI) {
 
28
  if (BI->getNumBits() != 1) return 0; // Only accept if just one bit!
 
29
  return BI->getBit(0);
 
30
}
 
31
 
 
32
bool BitRecTy::baseClassOf(const BitsRecTy *RHS) const {
 
33
  return RHS->getNumBits() == 1;
 
34
}
 
35
 
 
36
Init *BitRecTy::convertValue(IntInit *II) {
 
37
  int64_t Val = II->getValue();
 
38
  if (Val != 0 && Val != 1) return 0;  // Only accept 0 or 1 for a bit!
 
39
 
 
40
  return new BitInit(Val != 0);
 
41
}
 
42
 
 
43
Init *BitRecTy::convertValue(TypedInit *VI) {
 
44
  if (dynamic_cast<BitRecTy*>(VI->getType()))
 
45
    return VI;  // Accept variable if it is already of bit type!
 
46
  return 0;
 
47
}
 
48
 
 
49
std::string BitsRecTy::getAsString() const {
 
50
  return "bits<" + utostr(Size) + ">";
 
51
}
 
52
 
 
53
Init *BitsRecTy::convertValue(UnsetInit *UI) {
 
54
  BitsInit *Ret = new BitsInit(Size);
 
55
 
 
56
  for (unsigned i = 0; i != Size; ++i)
 
57
    Ret->setBit(i, new UnsetInit());
 
58
  return Ret;
 
59
}
 
60
 
 
61
Init *BitsRecTy::convertValue(BitInit *UI) {
 
62
  if (Size != 1) return 0;  // Can only convert single bit...
 
63
  BitsInit *Ret = new BitsInit(1);
 
64
  Ret->setBit(0, UI);
 
65
  return Ret;
 
66
}
 
67
 
 
68
// convertValue from Int initializer to bits type: Split the integer up into the
 
69
// appropriate bits...
 
70
//
 
71
Init *BitsRecTy::convertValue(IntInit *II) {
 
72
  int64_t Value = II->getValue();
 
73
  // Make sure this bitfield is large enough to hold the integer value...
 
74
  if (Value >= 0) {
 
75
    if (Value & ~((1LL << Size)-1))
 
76
      return 0;
 
77
  } else {
 
78
    if ((Value >> Size) != -1 || ((Value & (1LL << (Size-1))) == 0))
 
79
      return 0;
 
80
  }
 
81
 
 
82
  BitsInit *Ret = new BitsInit(Size);
 
83
  for (unsigned i = 0; i != Size; ++i)
 
84
    Ret->setBit(i, new BitInit(Value & (1LL << i)));
 
85
 
 
86
  return Ret;
 
87
}
 
88
 
 
89
Init *BitsRecTy::convertValue(BitsInit *BI) {
 
90
  // If the number of bits is right, return it.  Otherwise we need to expand or
 
91
  // truncate...
 
92
  if (BI->getNumBits() == Size) return BI;
 
93
  return 0;
 
94
}
 
95
 
 
96
Init *BitsRecTy::convertValue(TypedInit *VI) {
 
97
  if (BitsRecTy *BRT = dynamic_cast<BitsRecTy*>(VI->getType()))
 
98
    if (BRT->Size == Size) {
 
99
      BitsInit *Ret = new BitsInit(Size);
 
100
      for (unsigned i = 0; i != Size; ++i)
 
101
        Ret->setBit(i, new VarBitInit(VI, i));
 
102
      return Ret;
 
103
    }
 
104
  if (Size == 1 && dynamic_cast<BitRecTy*>(VI->getType())) {
 
105
    BitsInit *Ret = new BitsInit(1);
 
106
    Ret->setBit(0, VI);
 
107
    return Ret;
 
108
  }
 
109
 
 
110
  return 0;
 
111
}
 
112
 
 
113
Init *IntRecTy::convertValue(BitInit *BI) {
 
114
  return new IntInit(BI->getValue());
 
115
}
 
116
 
 
117
Init *IntRecTy::convertValue(BitsInit *BI) {
 
118
  int64_t Result = 0;
 
119
  for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i)
 
120
    if (BitInit *Bit = dynamic_cast<BitInit*>(BI->getBit(i))) {
 
121
      Result |= Bit->getValue() << i;
 
122
    } else {
 
123
      return 0;
 
124
    }
 
125
  return new IntInit(Result);
 
126
}
 
127
 
 
128
Init *IntRecTy::convertValue(TypedInit *TI) {
 
129
  if (TI->getType()->typeIsConvertibleTo(this))
 
130
    return TI;  // Accept variable if already of the right type!
 
131
  return 0;
 
132
}
 
133
 
 
134
Init *StringRecTy::convertValue(UnOpInit *BO) {
 
135
  if (BO->getOpcode() == UnOpInit::CAST) {
 
136
    Init *L = BO->getOperand()->convertInitializerTo(this);
 
137
    if (L == 0) return 0;
 
138
    if (L != BO->getOperand())
 
139
      return new UnOpInit(UnOpInit::CAST, L, new StringRecTy);
 
140
    return BO;
 
141
  }
 
142
 
 
143
  return convertValue((TypedInit*)BO);
 
144
}
 
145
 
 
146
Init *StringRecTy::convertValue(BinOpInit *BO) {
 
147
  if (BO->getOpcode() == BinOpInit::STRCONCAT) {
 
148
    Init *L = BO->getLHS()->convertInitializerTo(this);
 
149
    Init *R = BO->getRHS()->convertInitializerTo(this);
 
150
    if (L == 0 || R == 0) return 0;
 
151
    if (L != BO->getLHS() || R != BO->getRHS())
 
152
      return new BinOpInit(BinOpInit::STRCONCAT, L, R, new StringRecTy);
 
153
    return BO;
 
154
  }
 
155
  if (BO->getOpcode() == BinOpInit::NAMECONCAT) {
 
156
    if (BO->getType()->getAsString() == getAsString()) {
 
157
      Init *L = BO->getLHS()->convertInitializerTo(this);
 
158
      Init *R = BO->getRHS()->convertInitializerTo(this);
 
159
      if (L == 0 || R == 0) return 0;
 
160
      if (L != BO->getLHS() || R != BO->getRHS())
 
161
        return new BinOpInit(BinOpInit::NAMECONCAT, L, R, new StringRecTy);
 
162
      return BO;
 
163
    }
 
164
  }
 
165
 
 
166
  return convertValue((TypedInit*)BO);
 
167
}
 
168
 
 
169
 
 
170
Init *StringRecTy::convertValue(TypedInit *TI) {
 
171
  if (dynamic_cast<StringRecTy*>(TI->getType()))
 
172
    return TI;  // Accept variable if already of the right type!
 
173
  return 0;
 
174
}
 
175
 
 
176
std::string ListRecTy::getAsString() const {
 
177
  return "list<" + Ty->getAsString() + ">";
 
178
}
 
179
 
 
180
Init *ListRecTy::convertValue(ListInit *LI) {
 
181
  std::vector<Init*> Elements;
 
182
 
 
183
  // Verify that all of the elements of the list are subclasses of the
 
184
  // appropriate class!
 
185
  for (unsigned i = 0, e = LI->getSize(); i != e; ++i)
 
186
    if (Init *CI = LI->getElement(i)->convertInitializerTo(Ty))
 
187
      Elements.push_back(CI);
 
188
    else
 
189
      return 0;
 
190
 
 
191
  ListRecTy *LType = dynamic_cast<ListRecTy*>(LI->getType());
 
192
  if (LType == 0) {
 
193
    return 0;
 
194
  }
 
195
 
 
196
  return new ListInit(Elements, new ListRecTy(Ty));
 
197
}
 
198
 
 
199
Init *ListRecTy::convertValue(TypedInit *TI) {
 
200
  // Ensure that TI is compatible with our class.
 
201
  if (ListRecTy *LRT = dynamic_cast<ListRecTy*>(TI->getType()))
 
202
    if (LRT->getElementType()->typeIsConvertibleTo(getElementType()))
 
203
      return TI;
 
204
  return 0;
 
205
}
 
206
 
 
207
Init *CodeRecTy::convertValue(TypedInit *TI) {
 
208
  if (TI->getType()->typeIsConvertibleTo(this))
 
209
    return TI;
 
210
  return 0;
 
211
}
 
212
 
 
213
Init *DagRecTy::convertValue(TypedInit *TI) {
 
214
  if (TI->getType()->typeIsConvertibleTo(this))
 
215
    return TI;
 
216
  return 0;
 
217
}
 
218
 
 
219
Init *DagRecTy::convertValue(UnOpInit *BO) {
 
220
  if (BO->getOpcode() == UnOpInit::CAST) {
 
221
    Init *L = BO->getOperand()->convertInitializerTo(this);
 
222
    if (L == 0) return 0;
 
223
    if (L != BO->getOperand())
 
224
      return new UnOpInit(UnOpInit::CAST, L, new DagRecTy);
 
225
    return BO;
 
226
  }
 
227
  return 0;
 
228
}
 
229
 
 
230
Init *DagRecTy::convertValue(BinOpInit *BO) {
 
231
  if (BO->getOpcode() == BinOpInit::CONCAT) {
 
232
    Init *L = BO->getLHS()->convertInitializerTo(this);
 
233
    Init *R = BO->getRHS()->convertInitializerTo(this);
 
234
    if (L == 0 || R == 0) return 0;
 
235
    if (L != BO->getLHS() || R != BO->getRHS())
 
236
      return new BinOpInit(BinOpInit::CONCAT, L, R, new DagRecTy);
 
237
    return BO;
 
238
  }
 
239
  if (BO->getOpcode() == BinOpInit::NAMECONCAT) {
 
240
    if (BO->getType()->getAsString() == getAsString()) {
 
241
      Init *L = BO->getLHS()->convertInitializerTo(this);
 
242
      Init *R = BO->getRHS()->convertInitializerTo(this);
 
243
      if (L == 0 || R == 0) return 0;
 
244
      if (L != BO->getLHS() || R != BO->getRHS())
 
245
        return new BinOpInit(BinOpInit::CONCAT, L, R, new DagRecTy);
 
246
      return BO;
 
247
    }
 
248
  }
 
249
  return 0;
 
250
}
 
251
 
 
252
std::string RecordRecTy::getAsString() const {
 
253
  return Rec->getName();
 
254
}
 
255
 
 
256
Init *RecordRecTy::convertValue(DefInit *DI) {
 
257
  // Ensure that DI is a subclass of Rec.
 
258
  if (!DI->getDef()->isSubClassOf(Rec))
 
259
    return 0;
 
260
  return DI;
 
261
}
 
262
 
 
263
Init *RecordRecTy::convertValue(TypedInit *TI) {
 
264
  // Ensure that TI is compatible with Rec.
 
265
  if (RecordRecTy *RRT = dynamic_cast<RecordRecTy*>(TI->getType()))
 
266
    if (RRT->getRecord()->isSubClassOf(getRecord()) ||
 
267
        RRT->getRecord() == getRecord())
 
268
      return TI;
 
269
  return 0;
 
270
}
 
271
 
 
272
bool RecordRecTy::baseClassOf(const RecordRecTy *RHS) const {
 
273
  return Rec == RHS->getRecord() || RHS->getRecord()->isSubClassOf(Rec);
 
274
}
 
275
 
 
276
 
 
277
/// resolveTypes - Find a common type that T1 and T2 convert to.
 
278
/// Return 0 if no such type exists.
 
279
///
 
280
RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
 
281
  if (!T1->typeIsConvertibleTo(T2)) {
 
282
    if (!T2->typeIsConvertibleTo(T1)) {
 
283
      // If one is a Record type, check superclasses
 
284
      RecordRecTy *RecTy1 = dynamic_cast<RecordRecTy*>(T1);
 
285
      if (RecTy1) {
 
286
        // See if T2 inherits from a type T1 also inherits from
 
287
        const std::vector<Record *> &T1SuperClasses =
 
288
          RecTy1->getRecord()->getSuperClasses();
 
289
        for(std::vector<Record *>::const_iterator i = T1SuperClasses.begin(),
 
290
              iend = T1SuperClasses.end();
 
291
            i != iend;
 
292
            ++i) {
 
293
          RecordRecTy *SuperRecTy1 = new RecordRecTy(*i);
 
294
          RecTy *NewType1 = resolveTypes(SuperRecTy1, T2);
 
295
          if (NewType1 != 0) {
 
296
            if (NewType1 != SuperRecTy1) {
 
297
              delete SuperRecTy1;
 
298
            }
 
299
            return NewType1;
 
300
          }
 
301
        }
 
302
      }
 
303
      RecordRecTy *RecTy2 = dynamic_cast<RecordRecTy*>(T2);
 
304
      if (RecTy2) {
 
305
        // See if T1 inherits from a type T2 also inherits from
 
306
        const std::vector<Record *> &T2SuperClasses =
 
307
          RecTy2->getRecord()->getSuperClasses();
 
308
        for (std::vector<Record *>::const_iterator i = T2SuperClasses.begin(),
 
309
              iend = T2SuperClasses.end();
 
310
            i != iend;
 
311
            ++i) {
 
312
          RecordRecTy *SuperRecTy2 = new RecordRecTy(*i);
 
313
          RecTy *NewType2 = resolveTypes(T1, SuperRecTy2);
 
314
          if (NewType2 != 0) {
 
315
            if (NewType2 != SuperRecTy2) {
 
316
              delete SuperRecTy2;
 
317
            }
 
318
            return NewType2;
 
319
          }
 
320
        }
 
321
      }
 
322
      return 0;
 
323
    }
 
324
    return T2;
 
325
  }
 
326
  return T1;
 
327
}
 
328
 
 
329
 
 
330
//===----------------------------------------------------------------------===//
 
331
//    Initializer implementations
 
332
//===----------------------------------------------------------------------===//
 
333
 
 
334
void Init::dump() const { return print(errs()); }
 
335
 
 
336
Init *BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
 
337
  BitsInit *BI = new BitsInit(Bits.size());
 
338
  for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
 
339
    if (Bits[i] >= getNumBits()) {
 
340
      delete BI;
 
341
      return 0;
 
342
    }
 
343
    BI->setBit(i, getBit(Bits[i]));
 
344
  }
 
345
  return BI;
 
346
}
 
347
 
 
348
std::string BitsInit::getAsString() const {
 
349
  std::string Result = "{ ";
 
350
  for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
 
351
    if (i) Result += ", ";
 
352
    if (Init *Bit = getBit(e-i-1))
 
353
      Result += Bit->getAsString();
 
354
    else
 
355
      Result += "*";
 
356
  }
 
357
  return Result + " }";
 
358
}
 
359
 
 
360
// resolveReferences - If there are any field references that refer to fields
 
361
// that have been filled in, we can propagate the values now.
 
362
//
 
363
Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) {
 
364
  bool Changed = false;
 
365
  BitsInit *New = new BitsInit(getNumBits());
 
366
 
 
367
  for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
 
368
    Init *B;
 
369
    Init *CurBit = getBit(i);
 
370
 
 
371
    do {
 
372
      B = CurBit;
 
373
      CurBit = CurBit->resolveReferences(R, RV);
 
374
      Changed |= B != CurBit;
 
375
    } while (B != CurBit);
 
376
    New->setBit(i, CurBit);
 
377
  }
 
378
 
 
379
  if (Changed)
 
380
    return New;
 
381
  delete New;
 
382
  return this;
 
383
}
 
384
 
 
385
std::string IntInit::getAsString() const {
 
386
  return itostr(Value);
 
387
}
 
388
 
 
389
Init *IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
 
390
  BitsInit *BI = new BitsInit(Bits.size());
 
391
 
 
392
  for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
 
393
    if (Bits[i] >= 64) {
 
394
      delete BI;
 
395
      return 0;
 
396
    }
 
397
    BI->setBit(i, new BitInit(Value & (INT64_C(1) << Bits[i])));
 
398
  }
 
399
  return BI;
 
400
}
 
401
 
 
402
Init *ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
 
403
  std::vector<Init*> Vals;
 
404
  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
 
405
    if (Elements[i] >= getSize())
 
406
      return 0;
 
407
    Vals.push_back(getElement(Elements[i]));
 
408
  }
 
409
  return new ListInit(Vals, getType());
 
410
}
 
411
 
 
412
Record *ListInit::getElementAsRecord(unsigned i) const {
 
413
  assert(i < Values.size() && "List element index out of range!");
 
414
  DefInit *DI = dynamic_cast<DefInit*>(Values[i]);
 
415
  if (DI == 0) throw "Expected record in list!";
 
416
  return DI->getDef();
 
417
}
 
418
 
 
419
Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) {
 
420
  std::vector<Init*> Resolved;
 
421
  Resolved.reserve(getSize());
 
422
  bool Changed = false;
 
423
 
 
424
  for (unsigned i = 0, e = getSize(); i != e; ++i) {
 
425
    Init *E;
 
426
    Init *CurElt = getElement(i);
 
427
 
 
428
    do {
 
429
      E = CurElt;
 
430
      CurElt = CurElt->resolveReferences(R, RV);
 
431
      Changed |= E != CurElt;
 
432
    } while (E != CurElt);
 
433
    Resolved.push_back(E);
 
434
  }
 
435
 
 
436
  if (Changed)
 
437
    return new ListInit(Resolved, getType());
 
438
  return this;
 
439
}
 
440
 
 
441
Init *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV,
 
442
                                            unsigned Elt) {
 
443
  if (Elt >= getSize())
 
444
    return 0;  // Out of range reference.
 
445
  Init *E = getElement(Elt);
 
446
  // If the element is set to some value, or if we are resolving a reference
 
447
  // to a specific variable and that variable is explicitly unset, then
 
448
  // replace the VarListElementInit with it.
 
449
  if (IRV || !dynamic_cast<UnsetInit*>(E))
 
450
    return E;
 
451
  return 0;
 
452
}
 
453
 
 
454
std::string ListInit::getAsString() const {
 
455
  std::string Result = "[";
 
456
  for (unsigned i = 0, e = Values.size(); i != e; ++i) {
 
457
    if (i) Result += ", ";
 
458
    Result += Values[i]->getAsString();
 
459
  }
 
460
  return Result + "]";
 
461
}
 
462
 
 
463
Init *OpInit::resolveBitReference(Record &R, const RecordVal *IRV,
 
464
                                  unsigned Bit) {
 
465
  Init *Folded = Fold(&R, 0);
 
466
 
 
467
  if (Folded != this) {
 
468
    TypedInit *Typed = dynamic_cast<TypedInit *>(Folded);
 
469
    if (Typed) {
 
470
      return Typed->resolveBitReference(R, IRV, Bit);
 
471
    }
 
472
  }
 
473
 
 
474
  return 0;
 
475
}
 
476
 
 
477
Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV,
 
478
                                          unsigned Elt) {
 
479
  Init *Folded = Fold(&R, 0);
 
480
 
 
481
  if (Folded != this) {
 
482
    TypedInit *Typed = dynamic_cast<TypedInit *>(Folded);
 
483
    if (Typed) {
 
484
      return Typed->resolveListElementReference(R, IRV, Elt);
 
485
    }
 
486
  }
 
487
 
 
488
  return 0;
 
489
}
 
490
 
 
491
Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
 
492
  switch (getOpcode()) {
 
493
  default: assert(0 && "Unknown unop");
 
494
  case CAST: {
 
495
    if (getType()->getAsString() == "string") {
 
496
      StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
 
497
      if (LHSs) {
 
498
        return LHSs;
 
499
      }
 
500
 
 
501
      DefInit *LHSd = dynamic_cast<DefInit*>(LHS);
 
502
      if (LHSd) {
 
503
        return new StringInit(LHSd->getDef()->getName());
 
504
      }
 
505
    } else {
 
506
      StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
 
507
      if (LHSs) {
 
508
        std::string Name = LHSs->getValue();
 
509
 
 
510
        // From TGParser::ParseIDValue
 
511
        if (CurRec) {
 
512
          if (const RecordVal *RV = CurRec->getValue(Name)) {
 
513
            if (RV->getType() != getType()) {
 
514
              throw "type mismatch in nameconcat";
 
515
            }
 
516
            return new VarInit(Name, RV->getType());
 
517
          }
 
518
 
 
519
          std::string TemplateArgName = CurRec->getName()+":"+Name;
 
520
          if (CurRec->isTemplateArg(TemplateArgName)) {
 
521
            const RecordVal *RV = CurRec->getValue(TemplateArgName);
 
522
            assert(RV && "Template arg doesn't exist??");
 
523
 
 
524
            if (RV->getType() != getType()) {
 
525
              throw "type mismatch in nameconcat";
 
526
            }
 
527
 
 
528
            return new VarInit(TemplateArgName, RV->getType());
 
529
          }
 
530
        }
 
531
 
 
532
        if (CurMultiClass) {
 
533
          std::string MCName = CurMultiClass->Rec.getName()+"::"+Name;
 
534
          if (CurMultiClass->Rec.isTemplateArg(MCName)) {
 
535
            const RecordVal *RV = CurMultiClass->Rec.getValue(MCName);
 
536
            assert(RV && "Template arg doesn't exist??");
 
537
 
 
538
            if (RV->getType() != getType()) {
 
539
              throw "type mismatch in nameconcat";
 
540
            }
 
541
 
 
542
            return new VarInit(MCName, RV->getType());
 
543
          }
 
544
        }
 
545
 
 
546
        if (Record *D = Records.getDef(Name))
 
547
          return new DefInit(D);
 
548
 
 
549
        errs() << "Variable not defined: '" + Name + "'\n";
 
550
        assert(0 && "Variable not found");
 
551
        return 0;
 
552
      }
 
553
    }
 
554
    break;
 
555
  }
 
556
  case CAR: {
 
557
    ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
 
558
    if (LHSl) {
 
559
      if (LHSl->getSize() == 0) {
 
560
        assert(0 && "Empty list in car");
 
561
        return 0;
 
562
      }
 
563
      return LHSl->getElement(0);
 
564
    }
 
565
    break;
 
566
  }
 
567
  case CDR: {
 
568
    ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
 
569
    if (LHSl) {
 
570
      if (LHSl->getSize() == 0) {
 
571
        assert(0 && "Empty list in cdr");
 
572
        return 0;
 
573
      }
 
574
      ListInit *Result = new ListInit(LHSl->begin()+1, LHSl->end(),
 
575
                                      LHSl->getType());
 
576
      return Result;
 
577
    }
 
578
    break;
 
579
  }
 
580
  case LNULL: {
 
581
    ListInit *LHSl = dynamic_cast<ListInit*>(LHS);
 
582
    if (LHSl) {
 
583
      if (LHSl->getSize() == 0) {
 
584
        return new IntInit(1);
 
585
      } else {
 
586
        return new IntInit(0);
 
587
      }
 
588
    }
 
589
    StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
 
590
    if (LHSs) {
 
591
      if (LHSs->getValue().empty()) {
 
592
        return new IntInit(1);
 
593
      } else {
 
594
        return new IntInit(0);
 
595
      }
 
596
    }
 
597
 
 
598
    break;
 
599
  }
 
600
  }
 
601
  return this;
 
602
}
 
603
 
 
604
Init *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) {
 
605
  Init *lhs = LHS->resolveReferences(R, RV);
 
606
 
 
607
  if (LHS != lhs)
 
608
    return (new UnOpInit(getOpcode(), lhs, getType()))->Fold(&R, 0);
 
609
  return Fold(&R, 0);
 
610
}
 
611
 
 
612
std::string UnOpInit::getAsString() const {
 
613
  std::string Result;
 
614
  switch (Opc) {
 
615
  case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break;
 
616
  case CAR: Result = "!car"; break;
 
617
  case CDR: Result = "!cdr"; break;
 
618
  case LNULL: Result = "!null"; break;
 
619
  }
 
620
  return Result + "(" + LHS->getAsString() + ")";
 
621
}
 
622
 
 
623
RecTy *UnOpInit::getFieldType(const std::string &FieldName) const {
 
624
  switch (getOpcode()) {
 
625
  default: assert(0 && "Unknown unop");
 
626
  case CAST: {
 
627
    RecordRecTy *RecordType = dynamic_cast<RecordRecTy *>(getType());
 
628
    if (RecordType) {
 
629
      RecordVal *Field = RecordType->getRecord()->getValue(FieldName);
 
630
      if (Field) {
 
631
        return Field->getType();
 
632
      }
 
633
    }
 
634
    break;
 
635
  }
 
636
  }
 
637
  return 0;
 
638
}
 
639
 
 
640
Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
 
641
  switch (getOpcode()) {
 
642
  default: assert(0 && "Unknown binop");
 
643
  case CONCAT: {
 
644
    DagInit *LHSs = dynamic_cast<DagInit*>(LHS);
 
645
    DagInit *RHSs = dynamic_cast<DagInit*>(RHS);
 
646
    if (LHSs && RHSs) {
 
647
      DefInit *LOp = dynamic_cast<DefInit*>(LHSs->getOperator());
 
648
      DefInit *ROp = dynamic_cast<DefInit*>(RHSs->getOperator());
 
649
      if (LOp->getDef() != ROp->getDef()) {
 
650
        bool LIsOps =
 
651
          LOp->getDef()->getName() == "outs" ||
 
652
          LOp->getDef()->getName() != "ins" ||
 
653
          LOp->getDef()->getName() != "defs";
 
654
        bool RIsOps =
 
655
          ROp->getDef()->getName() == "outs" ||
 
656
          ROp->getDef()->getName() != "ins" ||
 
657
          ROp->getDef()->getName() != "defs";
 
658
        if (!LIsOps || !RIsOps)
 
659
          throw "Concated Dag operators do not match!";
 
660
      }
 
661
      std::vector<Init*> Args;
 
662
      std::vector<std::string> ArgNames;
 
663
      for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) {
 
664
        Args.push_back(LHSs->getArg(i));
 
665
        ArgNames.push_back(LHSs->getArgName(i));
 
666
      }
 
667
      for (unsigned i = 0, e = RHSs->getNumArgs(); i != e; ++i) {
 
668
        Args.push_back(RHSs->getArg(i));
 
669
        ArgNames.push_back(RHSs->getArgName(i));
 
670
      }
 
671
      return new DagInit(LHSs->getOperator(), "", Args, ArgNames);
 
672
    }
 
673
    break;
 
674
  }
 
675
  case STRCONCAT: {
 
676
    StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
 
677
    StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
 
678
    if (LHSs && RHSs)
 
679
      return new StringInit(LHSs->getValue() + RHSs->getValue());
 
680
    break;
 
681
  }
 
682
  case NAMECONCAT: {
 
683
    StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
 
684
    StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
 
685
    if (LHSs && RHSs) {
 
686
      std::string Name(LHSs->getValue() + RHSs->getValue());
 
687
 
 
688
      // From TGParser::ParseIDValue
 
689
      if (CurRec) {
 
690
        if (const RecordVal *RV = CurRec->getValue(Name)) {
 
691
          if (RV->getType() != getType()) {
 
692
            throw "type mismatch in nameconcat";
 
693
          }
 
694
          return new VarInit(Name, RV->getType());
 
695
        }
 
696
 
 
697
        std::string TemplateArgName = CurRec->getName()+":"+Name;
 
698
        if (CurRec->isTemplateArg(TemplateArgName)) {
 
699
          const RecordVal *RV = CurRec->getValue(TemplateArgName);
 
700
          assert(RV && "Template arg doesn't exist??");
 
701
 
 
702
          if (RV->getType() != getType()) {
 
703
            throw "type mismatch in nameconcat";
 
704
          }
 
705
 
 
706
          return new VarInit(TemplateArgName, RV->getType());
 
707
        }
 
708
      }
 
709
 
 
710
      if (CurMultiClass) {
 
711
        std::string MCName = CurMultiClass->Rec.getName()+"::"+Name;
 
712
        if (CurMultiClass->Rec.isTemplateArg(MCName)) {
 
713
          const RecordVal *RV = CurMultiClass->Rec.getValue(MCName);
 
714
          assert(RV && "Template arg doesn't exist??");
 
715
 
 
716
          if (RV->getType() != getType()) {
 
717
            throw "type mismatch in nameconcat";
 
718
          }
 
719
 
 
720
          return new VarInit(MCName, RV->getType());
 
721
        }
 
722
      }
 
723
 
 
724
      if (Record *D = Records.getDef(Name))
 
725
        return new DefInit(D);
 
726
 
 
727
      errs() << "Variable not defined in !nameconcat: '" + Name + "'\n";
 
728
      assert(0 && "Variable not found in !nameconcat");
 
729
      return 0;
 
730
    }
 
731
    break;
 
732
  }
 
733
  case EQ: {
 
734
    // Make sure we've resolved
 
735
    StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
 
736
    StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
 
737
    if (LHSs && RHSs)
 
738
      return new IntInit(LHSs->getValue() == RHSs->getValue());
 
739
 
 
740
    break;
 
741
  }
 
742
  case SHL:
 
743
  case SRA:
 
744
  case SRL: {
 
745
    IntInit *LHSi = dynamic_cast<IntInit*>(LHS);
 
746
    IntInit *RHSi = dynamic_cast<IntInit*>(RHS);
 
747
    if (LHSi && RHSi) {
 
748
      int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue();
 
749
      int64_t Result;
 
750
      switch (getOpcode()) {
 
751
      default: assert(0 && "Bad opcode!");
 
752
      case SHL: Result = LHSv << RHSv; break;
 
753
      case SRA: Result = LHSv >> RHSv; break;
 
754
      case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break;
 
755
      }
 
756
      return new IntInit(Result);
 
757
    }
 
758
    break;
 
759
  }
 
760
  }
 
761
  return this;
 
762
}
 
763
 
 
764
Init *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) {
 
765
  Init *lhs = LHS->resolveReferences(R, RV);
 
766
  Init *rhs = RHS->resolveReferences(R, RV);
 
767
 
 
768
  if (LHS != lhs || RHS != rhs)
 
769
    return (new BinOpInit(getOpcode(), lhs, rhs, getType()))->Fold(&R, 0);
 
770
  return Fold(&R, 0);
 
771
}
 
772
 
 
773
std::string BinOpInit::getAsString() const {
 
774
  std::string Result;
 
775
  switch (Opc) {
 
776
  case CONCAT: Result = "!con"; break;
 
777
  case SHL: Result = "!shl"; break;
 
778
  case SRA: Result = "!sra"; break;
 
779
  case SRL: Result = "!srl"; break;
 
780
  case EQ: Result = "!eq"; break;
 
781
  case STRCONCAT: Result = "!strconcat"; break;
 
782
  case NAMECONCAT:
 
783
    Result = "!nameconcat<" + getType()->getAsString() + ">"; break;
 
784
  }
 
785
  return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
 
786
}
 
787
 
 
788
static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
 
789
                           Record *CurRec, MultiClass *CurMultiClass);
 
790
 
 
791
static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
 
792
                               RecTy *Type, Record *CurRec,
 
793
                               MultiClass *CurMultiClass) {
 
794
  std::vector<Init *> NewOperands;
 
795
 
 
796
  TypedInit *TArg = dynamic_cast<TypedInit*>(Arg);
 
797
 
 
798
  // If this is a dag, recurse
 
799
  if (TArg && TArg->getType()->getAsString() == "dag") {
 
800
    Init *Result = ForeachHelper(LHS, Arg, RHSo, Type,
 
801
                                 CurRec, CurMultiClass);
 
802
    if (Result != 0) {
 
803
      return Result;
 
804
    } else {
 
805
      return 0;
 
806
    }
 
807
  }
 
808
 
 
809
  for (int i = 0; i < RHSo->getNumOperands(); ++i) {
 
810
    OpInit *RHSoo = dynamic_cast<OpInit*>(RHSo->getOperand(i));
 
811
 
 
812
    if (RHSoo) {
 
813
      Init *Result = EvaluateOperation(RHSoo, LHS, Arg,
 
814
                                       Type, CurRec, CurMultiClass);
 
815
      if (Result != 0) {
 
816
        NewOperands.push_back(Result);
 
817
      } else {
 
818
        NewOperands.push_back(Arg);
 
819
      }
 
820
    } else if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) {
 
821
      NewOperands.push_back(Arg);
 
822
    } else {
 
823
      NewOperands.push_back(RHSo->getOperand(i));
 
824
    }
 
825
  }
 
826
 
 
827
  // Now run the operator and use its result as the new leaf
 
828
  OpInit *NewOp = RHSo->clone(NewOperands);
 
829
  Init *NewVal = NewOp->Fold(CurRec, CurMultiClass);
 
830
  if (NewVal != NewOp) {
 
831
    delete NewOp;
 
832
    return NewVal;
 
833
  }
 
834
  return 0;
 
835
}
 
836
 
 
837
static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
 
838
                           Record *CurRec, MultiClass *CurMultiClass) {
 
839
  DagInit *MHSd = dynamic_cast<DagInit*>(MHS);
 
840
  ListInit *MHSl = dynamic_cast<ListInit*>(MHS);
 
841
 
 
842
  DagRecTy *DagType = dynamic_cast<DagRecTy*>(Type);
 
843
  ListRecTy *ListType = dynamic_cast<ListRecTy*>(Type);
 
844
 
 
845
  OpInit *RHSo = dynamic_cast<OpInit*>(RHS);
 
846
 
 
847
  if (!RHSo) {
 
848
    errs() << "!foreach requires an operator\n";
 
849
    assert(0 && "No operator for !foreach");
 
850
  }
 
851
 
 
852
  TypedInit *LHSt = dynamic_cast<TypedInit*>(LHS);
 
853
 
 
854
  if (!LHSt) {
 
855
    errs() << "!foreach requires typed variable\n";
 
856
    assert(0 && "No typed variable for !foreach");
 
857
  }
 
858
 
 
859
  if ((MHSd && DagType) || (MHSl && ListType)) {
 
860
    if (MHSd) {
 
861
      Init *Val = MHSd->getOperator();
 
862
      Init *Result = EvaluateOperation(RHSo, LHS, Val,
 
863
                                       Type, CurRec, CurMultiClass);
 
864
      if (Result != 0) {
 
865
        Val = Result;
 
866
      }
 
867
 
 
868
      std::vector<std::pair<Init *, std::string> > args;
 
869
      for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) {
 
870
        Init *Arg;
 
871
        std::string ArgName;
 
872
        Arg = MHSd->getArg(i);
 
873
        ArgName = MHSd->getArgName(i);
 
874
 
 
875
        // Process args
 
876
        Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type,
 
877
                                         CurRec, CurMultiClass);
 
878
        if (Result != 0) {
 
879
          Arg = Result;
 
880
        }
 
881
 
 
882
        // TODO: Process arg names
 
883
        args.push_back(std::make_pair(Arg, ArgName));
 
884
      }
 
885
 
 
886
      return new DagInit(Val, "", args);
 
887
    }
 
888
    if (MHSl) {
 
889
      std::vector<Init *> NewOperands;
 
890
      std::vector<Init *> NewList(MHSl->begin(), MHSl->end());
 
891
 
 
892
      for (ListInit::iterator li = NewList.begin(),
 
893
             liend = NewList.end();
 
894
           li != liend;
 
895
           ++li) {
 
896
        Init *Item = *li;
 
897
        NewOperands.clear();
 
898
        for(int i = 0; i < RHSo->getNumOperands(); ++i) {
 
899
          // First, replace the foreach variable with the list item
 
900
          if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) {
 
901
            NewOperands.push_back(Item);
 
902
          } else {
 
903
            NewOperands.push_back(RHSo->getOperand(i));
 
904
          }
 
905
        }
 
906
 
 
907
        // Now run the operator and use its result as the new list item
 
908
        OpInit *NewOp = RHSo->clone(NewOperands);
 
909
        Init *NewItem = NewOp->Fold(CurRec, CurMultiClass);
 
910
        if (NewItem != NewOp) {
 
911
          *li = NewItem;
 
912
          delete NewOp;
 
913
        }
 
914
      }
 
915
      return new ListInit(NewList, MHSl->getType());
 
916
    }
 
917
  }
 
918
  return 0;
 
919
}
 
920
 
 
921
Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) {
 
922
  switch (getOpcode()) {
 
923
  default: assert(0 && "Unknown binop");
 
924
  case SUBST: {
 
925
    DefInit *LHSd = dynamic_cast<DefInit*>(LHS);
 
926
    VarInit *LHSv = dynamic_cast<VarInit*>(LHS);
 
927
    StringInit *LHSs = dynamic_cast<StringInit*>(LHS);
 
928
 
 
929
    DefInit *MHSd = dynamic_cast<DefInit*>(MHS);
 
930
    VarInit *MHSv = dynamic_cast<VarInit*>(MHS);
 
931
    StringInit *MHSs = dynamic_cast<StringInit*>(MHS);
 
932
 
 
933
    DefInit *RHSd = dynamic_cast<DefInit*>(RHS);
 
934
    VarInit *RHSv = dynamic_cast<VarInit*>(RHS);
 
935
    StringInit *RHSs = dynamic_cast<StringInit*>(RHS);
 
936
 
 
937
    if ((LHSd && MHSd && RHSd)
 
938
        || (LHSv && MHSv && RHSv)
 
939
        || (LHSs && MHSs && RHSs)) {
 
940
      if (RHSd) {
 
941
        Record *Val = RHSd->getDef();
 
942
        if (LHSd->getAsString() == RHSd->getAsString()) {
 
943
          Val = MHSd->getDef();
 
944
        }
 
945
        return new DefInit(Val);
 
946
      }
 
947
      if (RHSv) {
 
948
        std::string Val = RHSv->getName();
 
949
        if (LHSv->getAsString() == RHSv->getAsString()) {
 
950
          Val = MHSv->getName();
 
951
        }
 
952
        return new VarInit(Val, getType());
 
953
      }
 
954
      if (RHSs) {
 
955
        std::string Val = RHSs->getValue();
 
956
 
 
957
        std::string::size_type found;
 
958
        std::string::size_type idx = 0;
 
959
        do {
 
960
          found = Val.find(LHSs->getValue(), idx);
 
961
          if (found != std::string::npos) {
 
962
            Val.replace(found, LHSs->getValue().size(), MHSs->getValue());
 
963
          }
 
964
          idx = found +  MHSs->getValue().size();
 
965
        } while (found != std::string::npos);
 
966
 
 
967
        return new StringInit(Val);
 
968
      }
 
969
    }
 
970
    break;
 
971
  }
 
972
 
 
973
  case FOREACH: {
 
974
    Init *Result = ForeachHelper(LHS, MHS, RHS, getType(),
 
975
                                 CurRec, CurMultiClass);
 
976
    if (Result != 0) {
 
977
      return Result;
 
978
    }
 
979
    break;
 
980
  }
 
981
 
 
982
  case IF: {
 
983
    IntInit *LHSi = dynamic_cast<IntInit*>(LHS);
 
984
    if (LHSi) {
 
985
      if (LHSi->getValue()) {
 
986
        return MHS;
 
987
      } else {
 
988
        return RHS;
 
989
      }
 
990
    }
 
991
    break;
 
992
  }
 
993
  }
 
994
 
 
995
  return this;
 
996
}
 
997
 
 
998
Init *TernOpInit::resolveReferences(Record &R, const RecordVal *RV) {
 
999
  Init *lhs = LHS->resolveReferences(R, RV);
 
1000
 
 
1001
  if (Opc == IF && lhs != LHS) {
 
1002
    IntInit *Value = dynamic_cast<IntInit*>(lhs);
 
1003
    if (Value != 0) {
 
1004
      // Short-circuit
 
1005
      if (Value->getValue()) {
 
1006
        Init *mhs = MHS->resolveReferences(R, RV);
 
1007
        return (new TernOpInit(getOpcode(), lhs, mhs,
 
1008
                               RHS, getType()))->Fold(&R, 0);
 
1009
      } else {
 
1010
        Init *rhs = RHS->resolveReferences(R, RV);
 
1011
        return (new TernOpInit(getOpcode(), lhs, MHS,
 
1012
                               rhs, getType()))->Fold(&R, 0);
 
1013
      }
 
1014
    }
 
1015
  }
 
1016
 
 
1017
  Init *mhs = MHS->resolveReferences(R, RV);
 
1018
  Init *rhs = RHS->resolveReferences(R, RV);
 
1019
 
 
1020
  if (LHS != lhs || MHS != mhs || RHS != rhs)
 
1021
    return (new TernOpInit(getOpcode(), lhs, mhs, rhs, getType()))->Fold(&R, 0);
 
1022
  return Fold(&R, 0);
 
1023
}
 
1024
 
 
1025
std::string TernOpInit::getAsString() const {
 
1026
  std::string Result;
 
1027
  switch (Opc) {
 
1028
  case SUBST: Result = "!subst"; break;
 
1029
  case FOREACH: Result = "!foreach"; break;
 
1030
  case IF: Result = "!if"; break;
 
1031
 }
 
1032
  return Result + "(" + LHS->getAsString() + ", " + MHS->getAsString() + ", "
 
1033
    + RHS->getAsString() + ")";
 
1034
}
 
1035
 
 
1036
Init *TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) {
 
1037
  BitsRecTy *T = dynamic_cast<BitsRecTy*>(getType());
 
1038
  if (T == 0) return 0;  // Cannot subscript a non-bits variable...
 
1039
  unsigned NumBits = T->getNumBits();
 
1040
 
 
1041
  BitsInit *BI = new BitsInit(Bits.size());
 
1042
  for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
 
1043
    if (Bits[i] >= NumBits) {
 
1044
      delete BI;
 
1045
      return 0;
 
1046
    }
 
1047
    BI->setBit(i, new VarBitInit(this, Bits[i]));
 
1048
  }
 
1049
  return BI;
 
1050
}
 
1051
 
 
1052
Init *TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) {
 
1053
  ListRecTy *T = dynamic_cast<ListRecTy*>(getType());
 
1054
  if (T == 0) return 0;  // Cannot subscript a non-list variable...
 
1055
 
 
1056
  if (Elements.size() == 1)
 
1057
    return new VarListElementInit(this, Elements[0]);
 
1058
 
 
1059
  std::vector<Init*> ListInits;
 
1060
  ListInits.reserve(Elements.size());
 
1061
  for (unsigned i = 0, e = Elements.size(); i != e; ++i)
 
1062
    ListInits.push_back(new VarListElementInit(this, Elements[i]));
 
1063
  return new ListInit(ListInits, T);
 
1064
}
 
1065
 
 
1066
 
 
1067
Init *VarInit::resolveBitReference(Record &R, const RecordVal *IRV,
 
1068
                                   unsigned Bit) {
 
1069
  if (R.isTemplateArg(getName())) return 0;
 
1070
  if (IRV && IRV->getName() != getName()) return 0;
 
1071
 
 
1072
  RecordVal *RV = R.getValue(getName());
 
1073
  assert(RV && "Reference to a non-existent variable?");
 
1074
  assert(dynamic_cast<BitsInit*>(RV->getValue()));
 
1075
  BitsInit *BI = (BitsInit*)RV->getValue();
 
1076
 
 
1077
  assert(Bit < BI->getNumBits() && "Bit reference out of range!");
 
1078
  Init *B = BI->getBit(Bit);
 
1079
 
 
1080
  // If the bit is set to some value, or if we are resolving a reference to a
 
1081
  // specific variable and that variable is explicitly unset, then replace the
 
1082
  // VarBitInit with it.
 
1083
  if (IRV || !dynamic_cast<UnsetInit*>(B))
 
1084
    return B;
 
1085
  return 0;
 
1086
}
 
1087
 
 
1088
Init *VarInit::resolveListElementReference(Record &R, const RecordVal *IRV,
 
1089
                                           unsigned Elt) {
 
1090
  if (R.isTemplateArg(getName())) return 0;
 
1091
  if (IRV && IRV->getName() != getName()) return 0;
 
1092
 
 
1093
  RecordVal *RV = R.getValue(getName());
 
1094
  assert(RV && "Reference to a non-existent variable?");
 
1095
  ListInit *LI = dynamic_cast<ListInit*>(RV->getValue());
 
1096
  if (!LI) {
 
1097
    VarInit *VI = dynamic_cast<VarInit*>(RV->getValue());
 
1098
    assert(VI && "Invalid list element!");
 
1099
    return new VarListElementInit(VI, Elt);
 
1100
  }
 
1101
 
 
1102
  if (Elt >= LI->getSize())
 
1103
    return 0;  // Out of range reference.
 
1104
  Init *E = LI->getElement(Elt);
 
1105
  // If the element is set to some value, or if we are resolving a reference
 
1106
  // to a specific variable and that variable is explicitly unset, then
 
1107
  // replace the VarListElementInit with it.
 
1108
  if (IRV || !dynamic_cast<UnsetInit*>(E))
 
1109
    return E;
 
1110
  return 0;
 
1111
}
 
1112
 
 
1113
 
 
1114
RecTy *VarInit::getFieldType(const std::string &FieldName) const {
 
1115
  if (RecordRecTy *RTy = dynamic_cast<RecordRecTy*>(getType()))
 
1116
    if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName))
 
1117
      return RV->getType();
 
1118
  return 0;
 
1119
}
 
1120
 
 
1121
Init *VarInit::getFieldInit(Record &R, const std::string &FieldName) const {
 
1122
  if (dynamic_cast<RecordRecTy*>(getType()))
 
1123
    if (const RecordVal *RV = R.getValue(VarName)) {
 
1124
      Init *TheInit = RV->getValue();
 
1125
      assert(TheInit != this && "Infinite loop detected!");
 
1126
      if (Init *I = TheInit->getFieldInit(R, FieldName))
 
1127
        return I;
 
1128
      else
 
1129
        return 0;
 
1130
    }
 
1131
  return 0;
 
1132
}
 
1133
 
 
1134
/// resolveReferences - This method is used by classes that refer to other
 
1135
/// variables which may not be defined at the time the expression is formed.
 
1136
/// If a value is set for the variable later, this method will be called on
 
1137
/// users of the value to allow the value to propagate out.
 
1138
///
 
1139
Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) {
 
1140
  if (RecordVal *Val = R.getValue(VarName))
 
1141
    if (RV == Val || (RV == 0 && !dynamic_cast<UnsetInit*>(Val->getValue())))
 
1142
      return Val->getValue();
 
1143
  return this;
 
1144
}
 
1145
 
 
1146
std::string VarBitInit::getAsString() const {
 
1147
   return TI->getAsString() + "{" + utostr(Bit) + "}";
 
1148
}
 
1149
 
 
1150
Init *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) {
 
1151
  if (Init *I = getVariable()->resolveBitReference(R, RV, getBitNum()))
 
1152
    return I;
 
1153
  return this;
 
1154
}
 
1155
 
 
1156
std::string VarListElementInit::getAsString() const {
 
1157
  return TI->getAsString() + "[" + utostr(Element) + "]";
 
1158
}
 
1159
 
 
1160
Init *VarListElementInit::resolveReferences(Record &R, const RecordVal *RV) {
 
1161
  if (Init *I = getVariable()->resolveListElementReference(R, RV,
 
1162
                                                           getElementNum()))
 
1163
    return I;
 
1164
  return this;
 
1165
}
 
1166
 
 
1167
Init *VarListElementInit::resolveBitReference(Record &R, const RecordVal *RV,
 
1168
                                              unsigned Bit) {
 
1169
  // FIXME: This should be implemented, to support references like:
 
1170
  // bit B = AA[0]{1};
 
1171
  return 0;
 
1172
}
 
1173
 
 
1174
Init *VarListElementInit::
 
1175
resolveListElementReference(Record &R, const RecordVal *RV, unsigned Elt) {
 
1176
  // FIXME: This should be implemented, to support references like:
 
1177
  // int B = AA[0][1];
 
1178
  return 0;
 
1179
}
 
1180
 
 
1181
RecTy *DefInit::getFieldType(const std::string &FieldName) const {
 
1182
  if (const RecordVal *RV = Def->getValue(FieldName))
 
1183
    return RV->getType();
 
1184
  return 0;
 
1185
}
 
1186
 
 
1187
Init *DefInit::getFieldInit(Record &R, const std::string &FieldName) const {
 
1188
  return Def->getValue(FieldName)->getValue();
 
1189
}
 
1190
 
 
1191
 
 
1192
std::string DefInit::getAsString() const {
 
1193
  return Def->getName();
 
1194
}
 
1195
 
 
1196
Init *FieldInit::resolveBitReference(Record &R, const RecordVal *RV,
 
1197
                                     unsigned Bit) {
 
1198
  if (Init *BitsVal = Rec->getFieldInit(R, FieldName))
 
1199
    if (BitsInit *BI = dynamic_cast<BitsInit*>(BitsVal)) {
 
1200
      assert(Bit < BI->getNumBits() && "Bit reference out of range!");
 
1201
      Init *B = BI->getBit(Bit);
 
1202
 
 
1203
      if (dynamic_cast<BitInit*>(B))  // If the bit is set...
 
1204
        return B;                     // Replace the VarBitInit with it.
 
1205
    }
 
1206
  return 0;
 
1207
}
 
1208
 
 
1209
Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV,
 
1210
                                             unsigned Elt) {
 
1211
  if (Init *ListVal = Rec->getFieldInit(R, FieldName))
 
1212
    if (ListInit *LI = dynamic_cast<ListInit*>(ListVal)) {
 
1213
      if (Elt >= LI->getSize()) return 0;
 
1214
      Init *E = LI->getElement(Elt);
 
1215
 
 
1216
      // If the element is set to some value, or if we are resolving a
 
1217
      // reference to a specific variable and that variable is explicitly
 
1218
      // unset, then replace the VarListElementInit with it.
 
1219
      if (RV || !dynamic_cast<UnsetInit*>(E))
 
1220
        return E;
 
1221
    }
 
1222
  return 0;
 
1223
}
 
1224
 
 
1225
Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) {
 
1226
  Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec;
 
1227
 
 
1228
  Init *BitsVal = NewRec->getFieldInit(R, FieldName);
 
1229
  if (BitsVal) {
 
1230
    Init *BVR = BitsVal->resolveReferences(R, RV);
 
1231
    return BVR->isComplete() ? BVR : this;
 
1232
  }
 
1233
 
 
1234
  if (NewRec != Rec) {
 
1235
    return new FieldInit(NewRec, FieldName);
 
1236
  }
 
1237
  return this;
 
1238
}
 
1239
 
 
1240
Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) {
 
1241
  std::vector<Init*> NewArgs;
 
1242
  for (unsigned i = 0, e = Args.size(); i != e; ++i)
 
1243
    NewArgs.push_back(Args[i]->resolveReferences(R, RV));
 
1244
 
 
1245
  Init *Op = Val->resolveReferences(R, RV);
 
1246
 
 
1247
  if (Args != NewArgs || Op != Val)
 
1248
    return new DagInit(Op, "", NewArgs, ArgNames);
 
1249
 
 
1250
  return this;
 
1251
}
 
1252
 
 
1253
 
 
1254
std::string DagInit::getAsString() const {
 
1255
  std::string Result = "(" + Val->getAsString();
 
1256
  if (!ValName.empty())
 
1257
    Result += ":" + ValName;
 
1258
  if (Args.size()) {
 
1259
    Result += " " + Args[0]->getAsString();
 
1260
    if (!ArgNames[0].empty()) Result += ":$" + ArgNames[0];
 
1261
    for (unsigned i = 1, e = Args.size(); i != e; ++i) {
 
1262
      Result += ", " + Args[i]->getAsString();
 
1263
      if (!ArgNames[i].empty()) Result += ":$" + ArgNames[i];
 
1264
    }
 
1265
  }
 
1266
  return Result + ")";
 
1267
}
 
1268
 
 
1269
 
 
1270
//===----------------------------------------------------------------------===//
 
1271
//    Other implementations
 
1272
//===----------------------------------------------------------------------===//
 
1273
 
 
1274
RecordVal::RecordVal(const std::string &N, RecTy *T, unsigned P)
 
1275
  : Name(N), Ty(T), Prefix(P) {
 
1276
  Value = Ty->convertValue(new UnsetInit());
 
1277
  assert(Value && "Cannot create unset value for current type!");
 
1278
}
 
1279
 
 
1280
void RecordVal::dump() const { errs() << *this; }
 
1281
 
 
1282
void RecordVal::print(raw_ostream &OS, bool PrintSem) const {
 
1283
  if (getPrefix()) OS << "field ";
 
1284
  OS << *getType() << " " << getName();
 
1285
 
 
1286
  if (getValue())
 
1287
    OS << " = " << *getValue();
 
1288
 
 
1289
  if (PrintSem) OS << ";\n";
 
1290
}
 
1291
 
 
1292
unsigned Record::LastID = 0;
 
1293
 
 
1294
void Record::setName(const std::string &Name) {
 
1295
  if (Records.getDef(getName()) == this) {
 
1296
    Records.removeDef(getName());
 
1297
    this->Name = Name;
 
1298
    Records.addDef(this);
 
1299
  } else {
 
1300
    Records.removeClass(getName());
 
1301
    this->Name = Name;
 
1302
    Records.addClass(this);
 
1303
  }
 
1304
}
 
1305
 
 
1306
/// resolveReferencesTo - If anything in this record refers to RV, replace the
 
1307
/// reference to RV with the RHS of RV.  If RV is null, we resolve all possible
 
1308
/// references.
 
1309
void Record::resolveReferencesTo(const RecordVal *RV) {
 
1310
  for (unsigned i = 0, e = Values.size(); i != e; ++i) {
 
1311
    if (Init *V = Values[i].getValue())
 
1312
      Values[i].setValue(V->resolveReferences(*this, RV));
 
1313
  }
 
1314
}
 
1315
 
 
1316
 
 
1317
void Record::dump() const { errs() << *this; }
 
1318
 
 
1319
raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) {
 
1320
  OS << R.getName();
 
1321
 
 
1322
  const std::vector<std::string> &TArgs = R.getTemplateArgs();
 
1323
  if (!TArgs.empty()) {
 
1324
    OS << "<";
 
1325
    for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
 
1326
      if (i) OS << ", ";
 
1327
      const RecordVal *RV = R.getValue(TArgs[i]);
 
1328
      assert(RV && "Template argument record not found??");
 
1329
      RV->print(OS, false);
 
1330
    }
 
1331
    OS << ">";
 
1332
  }
 
1333
 
 
1334
  OS << " {";
 
1335
  const std::vector<Record*> &SC = R.getSuperClasses();
 
1336
  if (!SC.empty()) {
 
1337
    OS << "\t//";
 
1338
    for (unsigned i = 0, e = SC.size(); i != e; ++i)
 
1339
      OS << " " << SC[i]->getName();
 
1340
  }
 
1341
  OS << "\n";
 
1342
 
 
1343
  const std::vector<RecordVal> &Vals = R.getValues();
 
1344
  for (unsigned i = 0, e = Vals.size(); i != e; ++i)
 
1345
    if (Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName()))
 
1346
      OS << Vals[i];
 
1347
  for (unsigned i = 0, e = Vals.size(); i != e; ++i)
 
1348
    if (!Vals[i].getPrefix() && !R.isTemplateArg(Vals[i].getName()))
 
1349
      OS << Vals[i];
 
1350
 
 
1351
  return OS << "}\n";
 
1352
}
 
1353
 
 
1354
/// getValueInit - Return the initializer for a value with the specified name,
 
1355
/// or throw an exception if the field does not exist.
 
1356
///
 
1357
Init *Record::getValueInit(StringRef FieldName) const {
 
1358
  const RecordVal *R = getValue(FieldName);
 
1359
  if (R == 0 || R->getValue() == 0)
 
1360
    throw "Record `" + getName() + "' does not have a field named `" +
 
1361
      FieldName.str() + "'!\n";
 
1362
  return R->getValue();
 
1363
}
 
1364
 
 
1365
 
 
1366
/// getValueAsString - This method looks up the specified field and returns its
 
1367
/// value as a string, throwing an exception if the field does not exist or if
 
1368
/// the value is not a string.
 
1369
///
 
1370
std::string Record::getValueAsString(StringRef FieldName) const {
 
1371
  const RecordVal *R = getValue(FieldName);
 
1372
  if (R == 0 || R->getValue() == 0)
 
1373
    throw "Record `" + getName() + "' does not have a field named `" +
 
1374
          FieldName.str() + "'!\n";
 
1375
 
 
1376
  if (const StringInit *SI = dynamic_cast<const StringInit*>(R->getValue()))
 
1377
    return SI->getValue();
 
1378
  throw "Record `" + getName() + "', field `" + FieldName.str() +
 
1379
        "' does not have a string initializer!";
 
1380
}
 
1381
 
 
1382
/// getValueAsBitsInit - This method looks up the specified field and returns
 
1383
/// its value as a BitsInit, throwing an exception if the field does not exist
 
1384
/// or if the value is not the right type.
 
1385
///
 
1386
BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
 
1387
  const RecordVal *R = getValue(FieldName);
 
1388
  if (R == 0 || R->getValue() == 0)
 
1389
    throw "Record `" + getName() + "' does not have a field named `" +
 
1390
          FieldName.str() + "'!\n";
 
1391
 
 
1392
  if (BitsInit *BI = dynamic_cast<BitsInit*>(R->getValue()))
 
1393
    return BI;
 
1394
  throw "Record `" + getName() + "', field `" + FieldName.str() +
 
1395
        "' does not have a BitsInit initializer!";
 
1396
}
 
1397
 
 
1398
/// getValueAsListInit - This method looks up the specified field and returns
 
1399
/// its value as a ListInit, throwing an exception if the field does not exist
 
1400
/// or if the value is not the right type.
 
1401
///
 
1402
ListInit *Record::getValueAsListInit(StringRef FieldName) const {
 
1403
  const RecordVal *R = getValue(FieldName);
 
1404
  if (R == 0 || R->getValue() == 0)
 
1405
    throw "Record `" + getName() + "' does not have a field named `" +
 
1406
          FieldName.str() + "'!\n";
 
1407
 
 
1408
  if (ListInit *LI = dynamic_cast<ListInit*>(R->getValue()))
 
1409
    return LI;
 
1410
  throw "Record `" + getName() + "', field `" + FieldName.str() +
 
1411
        "' does not have a list initializer!";
 
1412
}
 
1413
 
 
1414
/// getValueAsListOfDefs - This method looks up the specified field and returns
 
1415
/// its value as a vector of records, throwing an exception if the field does
 
1416
/// not exist or if the value is not the right type.
 
1417
///
 
1418
std::vector<Record*>
 
1419
Record::getValueAsListOfDefs(StringRef FieldName) const {
 
1420
  ListInit *List = getValueAsListInit(FieldName);
 
1421
  std::vector<Record*> Defs;
 
1422
  for (unsigned i = 0; i < List->getSize(); i++) {
 
1423
    if (DefInit *DI = dynamic_cast<DefInit*>(List->getElement(i))) {
 
1424
      Defs.push_back(DI->getDef());
 
1425
    } else {
 
1426
      throw "Record `" + getName() + "', field `" + FieldName.str() +
 
1427
            "' list is not entirely DefInit!";
 
1428
    }
 
1429
  }
 
1430
  return Defs;
 
1431
}
 
1432
 
 
1433
/// getValueAsInt - This method looks up the specified field and returns its
 
1434
/// value as an int64_t, throwing an exception if the field does not exist or if
 
1435
/// the value is not the right type.
 
1436
///
 
1437
int64_t Record::getValueAsInt(StringRef FieldName) const {
 
1438
  const RecordVal *R = getValue(FieldName);
 
1439
  if (R == 0 || R->getValue() == 0)
 
1440
    throw "Record `" + getName() + "' does not have a field named `" +
 
1441
          FieldName.str() + "'!\n";
 
1442
 
 
1443
  if (IntInit *II = dynamic_cast<IntInit*>(R->getValue()))
 
1444
    return II->getValue();
 
1445
  throw "Record `" + getName() + "', field `" + FieldName.str() +
 
1446
        "' does not have an int initializer!";
 
1447
}
 
1448
 
 
1449
/// getValueAsListOfInts - This method looks up the specified field and returns
 
1450
/// its value as a vector of integers, throwing an exception if the field does
 
1451
/// not exist or if the value is not the right type.
 
1452
///
 
1453
std::vector<int64_t>
 
1454
Record::getValueAsListOfInts(StringRef FieldName) const {
 
1455
  ListInit *List = getValueAsListInit(FieldName);
 
1456
  std::vector<int64_t> Ints;
 
1457
  for (unsigned i = 0; i < List->getSize(); i++) {
 
1458
    if (IntInit *II = dynamic_cast<IntInit*>(List->getElement(i))) {
 
1459
      Ints.push_back(II->getValue());
 
1460
    } else {
 
1461
      throw "Record `" + getName() + "', field `" + FieldName.str() +
 
1462
            "' does not have a list of ints initializer!";
 
1463
    }
 
1464
  }
 
1465
  return Ints;
 
1466
}
 
1467
 
 
1468
/// getValueAsDef - This method looks up the specified field and returns its
 
1469
/// value as a Record, throwing an exception if the field does not exist or if
 
1470
/// the value is not the right type.
 
1471
///
 
1472
Record *Record::getValueAsDef(StringRef FieldName) const {
 
1473
  const RecordVal *R = getValue(FieldName);
 
1474
  if (R == 0 || R->getValue() == 0)
 
1475
    throw "Record `" + getName() + "' does not have a field named `" +
 
1476
      FieldName.str() + "'!\n";
 
1477
 
 
1478
  if (DefInit *DI = dynamic_cast<DefInit*>(R->getValue()))
 
1479
    return DI->getDef();
 
1480
  throw "Record `" + getName() + "', field `" + FieldName.str() +
 
1481
        "' does not have a def initializer!";
 
1482
}
 
1483
 
 
1484
/// getValueAsBit - This method looks up the specified field and returns its
 
1485
/// value as a bit, throwing an exception if the field does not exist or if
 
1486
/// the value is not the right type.
 
1487
///
 
1488
bool Record::getValueAsBit(StringRef FieldName) const {
 
1489
  const RecordVal *R = getValue(FieldName);
 
1490
  if (R == 0 || R->getValue() == 0)
 
1491
    throw "Record `" + getName() + "' does not have a field named `" +
 
1492
      FieldName.str() + "'!\n";
 
1493
 
 
1494
  if (BitInit *BI = dynamic_cast<BitInit*>(R->getValue()))
 
1495
    return BI->getValue();
 
1496
  throw "Record `" + getName() + "', field `" + FieldName.str() +
 
1497
        "' does not have a bit initializer!";
 
1498
}
 
1499
 
 
1500
/// getValueAsDag - This method looks up the specified field and returns its
 
1501
/// value as an Dag, throwing an exception if the field does not exist or if
 
1502
/// the value is not the right type.
 
1503
///
 
1504
DagInit *Record::getValueAsDag(StringRef FieldName) const {
 
1505
  const RecordVal *R = getValue(FieldName);
 
1506
  if (R == 0 || R->getValue() == 0)
 
1507
    throw "Record `" + getName() + "' does not have a field named `" +
 
1508
      FieldName.str() + "'!\n";
 
1509
 
 
1510
  if (DagInit *DI = dynamic_cast<DagInit*>(R->getValue()))
 
1511
    return DI;
 
1512
  throw "Record `" + getName() + "', field `" + FieldName.str() +
 
1513
        "' does not have a dag initializer!";
 
1514
}
 
1515
 
 
1516
std::string Record::getValueAsCode(StringRef FieldName) const {
 
1517
  const RecordVal *R = getValue(FieldName);
 
1518
  if (R == 0 || R->getValue() == 0)
 
1519
    throw "Record `" + getName() + "' does not have a field named `" +
 
1520
      FieldName.str() + "'!\n";
 
1521
 
 
1522
  if (const CodeInit *CI = dynamic_cast<const CodeInit*>(R->getValue()))
 
1523
    return CI->getValue();
 
1524
  throw "Record `" + getName() + "', field `" + FieldName.str() +
 
1525
    "' does not have a code initializer!";
 
1526
}
 
1527
 
 
1528
 
 
1529
void MultiClass::dump() const {
 
1530
  errs() << "Record:\n";
 
1531
  Rec.dump();
 
1532
 
 
1533
  errs() << "Defs:\n";
 
1534
  for (RecordVector::const_iterator r = DefPrototypes.begin(),
 
1535
         rend = DefPrototypes.end();
 
1536
       r != rend;
 
1537
       ++r) {
 
1538
    (*r)->dump();
 
1539
  }
 
1540
}
 
1541
 
 
1542
 
 
1543
void RecordKeeper::dump() const { errs() << *this; }
 
1544
 
 
1545
raw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) {
 
1546
  OS << "------------- Classes -----------------\n";
 
1547
  const std::map<std::string, Record*> &Classes = RK.getClasses();
 
1548
  for (std::map<std::string, Record*>::const_iterator I = Classes.begin(),
 
1549
         E = Classes.end(); I != E; ++I)
 
1550
    OS << "class " << *I->second;
 
1551
 
 
1552
  OS << "------------- Defs -----------------\n";
 
1553
  const std::map<std::string, Record*> &Defs = RK.getDefs();
 
1554
  for (std::map<std::string, Record*>::const_iterator I = Defs.begin(),
 
1555
         E = Defs.end(); I != E; ++I)
 
1556
    OS << "def " << *I->second;
 
1557
  return OS;
 
1558
}
 
1559
 
 
1560
 
 
1561
/// getAllDerivedDefinitions - This method returns all concrete definitions
 
1562
/// that derive from the specified class name.  If a class with the specified
 
1563
/// name does not exist, an error is printed and true is returned.
 
1564
std::vector<Record*>
 
1565
RecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const {
 
1566
  Record *Class = Records.getClass(ClassName);
 
1567
  if (!Class)
 
1568
    throw "ERROR: Couldn't find the `" + ClassName + "' class!\n";
 
1569
 
 
1570
  std::vector<Record*> Defs;
 
1571
  for (std::map<std::string, Record*>::const_iterator I = getDefs().begin(),
 
1572
         E = getDefs().end(); I != E; ++I)
 
1573
    if (I->second->isSubClassOf(Class))
 
1574
      Defs.push_back(I->second);
 
1575
 
 
1576
  return Defs;
 
1577
}
 
1578