← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/CodeGen/AsmPrinter/DIE.h

  • 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/lib/CodeGen/AsmPrinter/DIE.h
 
1
//===--- lib/CodeGen/DIE.h - DWARF Info Entries -----------------*- C++ -*-===//
 
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
// Data structures for DWARF info entries.
 
11
// 
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#ifndef CODEGEN_ASMPRINTER_DIE_H__
 
15
#define CODEGEN_ASMPRINTER_DIE_H__
 
16
 
 
17
#include "DwarfLabel.h"
 
18
#include "llvm/ADT/FoldingSet.h"
 
19
#include "llvm/ADT/SmallVector.h"
 
20
#include "llvm/Support/Compiler.h"
 
21
#include "llvm/Support/Dwarf.h"
 
22
#include <vector>
 
23
 
 
24
namespace llvm {
 
25
  class AsmPrinter;
 
26
  class DwarfPrinter;
 
27
  class TargetData;
 
28
  class MCSymbol;
 
29
 
 
30
  //===--------------------------------------------------------------------===//
 
31
  /// DIEAbbrevData - Dwarf abbreviation data, describes the one attribute of a
 
32
  /// Dwarf abbreviation.
 
33
  class DIEAbbrevData {
 
34
    /// Attribute - Dwarf attribute code.
 
35
    ///
 
36
    unsigned Attribute;
 
37
 
 
38
    /// Form - Dwarf form code.
 
39
    ///
 
40
    unsigned Form;
 
41
  public:
 
42
    DIEAbbrevData(unsigned A, unsigned F) : Attribute(A), Form(F) {}
 
43
 
 
44
    // Accessors.
 
45
    unsigned getAttribute() const { return Attribute; }
 
46
    unsigned getForm()      const { return Form; }
 
47
 
 
48
    /// Profile - Used to gather unique data for the abbreviation folding set.
 
49
    ///
 
50
    void Profile(FoldingSetNodeID &ID) const;
 
51
  };
 
52
 
 
53
  //===--------------------------------------------------------------------===//
 
54
  /// DIEAbbrev - Dwarf abbreviation, describes the organization of a debug
 
55
  /// information object.
 
56
  class DIEAbbrev : public FoldingSetNode {
 
57
    /// Tag - Dwarf tag code.
 
58
    ///
 
59
    unsigned Tag;
 
60
 
 
61
    /// Unique number for node.
 
62
    ///
 
63
    unsigned Number;
 
64
 
 
65
    /// ChildrenFlag - Dwarf children flag.
 
66
    ///
 
67
    unsigned ChildrenFlag;
 
68
 
 
69
    /// Data - Raw data bytes for abbreviation.
 
70
    ///
 
71
    SmallVector<DIEAbbrevData, 8> Data;
 
72
 
 
73
  public:
 
74
    DIEAbbrev(unsigned T, unsigned C) : Tag(T), ChildrenFlag(C), Data() {}
 
75
    virtual ~DIEAbbrev() {}
 
76
 
 
77
    // Accessors.
 
78
    unsigned getTag() const { return Tag; }
 
79
    unsigned getNumber() const { return Number; }
 
80
    unsigned getChildrenFlag() const { return ChildrenFlag; }
 
81
    const SmallVector<DIEAbbrevData, 8> &getData() const { return Data; }
 
82
    void setTag(unsigned T) { Tag = T; }
 
83
    void setChildrenFlag(unsigned CF) { ChildrenFlag = CF; }
 
84
    void setNumber(unsigned N) { Number = N; }
 
85
 
 
86
    /// AddAttribute - Adds another set of attribute information to the
 
87
    /// abbreviation.
 
88
    void AddAttribute(unsigned Attribute, unsigned Form) {
 
89
      Data.push_back(DIEAbbrevData(Attribute, Form));
 
90
    }
 
91
 
 
92
    /// AddFirstAttribute - Adds a set of attribute information to the front
 
93
    /// of the abbreviation.
 
94
    void AddFirstAttribute(unsigned Attribute, unsigned Form) {
 
95
      Data.insert(Data.begin(), DIEAbbrevData(Attribute, Form));
 
96
    }
 
97
 
 
98
    /// Profile - Used to gather unique data for the abbreviation folding set.
 
99
    ///
 
100
    void Profile(FoldingSetNodeID &ID) const;
 
101
 
 
102
    /// Emit - Print the abbreviation using the specified asm printer.
 
103
    ///
 
104
    void Emit(const DwarfPrinter *DP) const;
 
105
 
 
106
#ifndef NDEBUG
 
107
    void print(raw_ostream &O);
 
108
    void dump();
 
109
#endif
 
110
  };
 
111
 
 
112
  //===--------------------------------------------------------------------===//
 
113
  /// DIE - A structured debug information entry.  Has an abbreviation which
 
114
  /// describes it's organization.
 
115
  class CompileUnit;
 
116
  class DIEValue;
 
117
 
 
118
  class DIE {
 
119
  protected:
 
120
    /// Abbrev - Buffer for constructing abbreviation.
 
121
    ///
 
122
    DIEAbbrev Abbrev;
 
123
 
 
124
    /// Offset - Offset in debug info section.
 
125
    ///
 
126
    unsigned Offset;
 
127
 
 
128
    /// Size - Size of instance + children.
 
129
    ///
 
130
    unsigned Size;
 
131
 
 
132
    /// Children DIEs.
 
133
    ///
 
134
    std::vector<DIE *> Children;
 
135
 
 
136
    DIE *Parent;
 
137
 
 
138
    /// Attributes values.
 
139
    ///
 
140
    SmallVector<DIEValue*, 32> Values;
 
141
 
 
142
    // Private data for print()
 
143
    mutable unsigned IndentCount;
 
144
  public:
 
145
    explicit DIE(unsigned Tag)
 
146
      : Abbrev(Tag, dwarf::DW_CHILDREN_no), Offset(0),
 
147
        Size(0), Parent (0), IndentCount(0) {}
 
148
    virtual ~DIE();
 
149
 
 
150
    // Accessors.
 
151
    DIEAbbrev &getAbbrev() { return Abbrev; }
 
152
    unsigned getAbbrevNumber() const { return Abbrev.getNumber(); }
 
153
    unsigned getTag() const { return Abbrev.getTag(); }
 
154
    unsigned getOffset() const { return Offset; }
 
155
    unsigned getSize() const { return Size; }
 
156
    const std::vector<DIE *> &getChildren() const { return Children; }
 
157
    SmallVector<DIEValue*, 32> &getValues() { return Values; }
 
158
    DIE *getParent() const { return Parent; }
 
159
    void setTag(unsigned Tag) { Abbrev.setTag(Tag); }
 
160
    void setOffset(unsigned O) { Offset = O; }
 
161
    void setSize(unsigned S) { Size = S; }
 
162
    void setParent(DIE *P) { Parent = P; }
 
163
    
 
164
    /// addValue - Add a value and attributes to a DIE.
 
165
    ///
 
166
    void addValue(unsigned Attribute, unsigned Form, DIEValue *Value) {
 
167
      Abbrev.AddAttribute(Attribute, Form);
 
168
      Values.push_back(Value);
 
169
    }
 
170
 
 
171
    /// SiblingOffset - Return the offset of the debug information entry's
 
172
    /// sibling.
 
173
    unsigned getSiblingOffset() const { return Offset + Size; }
 
174
 
 
175
    /// addSiblingOffset - Add a sibling offset field to the front of the DIE.
 
176
    ///
 
177
    void addSiblingOffset();
 
178
 
 
179
    /// addChild - Add a child to the DIE.
 
180
    ///
 
181
    void addChild(DIE *Child) {
 
182
      if (Child->getParent()) {
 
183
        assert (Child->getParent() == this && "Unexpected DIE Parent!");
 
184
        return;
 
185
      }
 
186
      Abbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes);
 
187
      Children.push_back(Child);
 
188
      Child->setParent(this);
 
189
    }
 
190
 
 
191
#ifndef NDEBUG
 
192
    void print(raw_ostream &O, unsigned IncIndent = 0);
 
193
    void dump();
 
194
#endif
 
195
  };
 
196
 
 
197
  //===--------------------------------------------------------------------===//
 
198
  /// DIEValue - A debug information entry value.
 
199
  ///
 
200
  class DIEValue {
 
201
  public:
 
202
    enum {
 
203
      isInteger,
 
204
      isString,
 
205
      isLabel,
 
206
      isAsIsLabel,
 
207
      isSectionOffset,
 
208
      isDelta,
 
209
      isEntry,
 
210
      isBlock
 
211
    };
 
212
  protected:
 
213
    /// Type - Type of data stored in the value.
 
214
    ///
 
215
    unsigned Type;
 
216
  public:
 
217
    explicit DIEValue(unsigned T) : Type(T) {}
 
218
    virtual ~DIEValue() {}
 
219
 
 
220
    // Accessors
 
221
    unsigned getType()  const { return Type; }
 
222
 
 
223
    /// EmitValue - Emit value via the Dwarf writer.
 
224
    ///
 
225
    virtual void EmitValue(DwarfPrinter *D, unsigned Form) const = 0;
 
226
 
 
227
    /// SizeOf - Return the size of a value in bytes.
 
228
    ///
 
229
    virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const = 0;
 
230
 
 
231
    // Implement isa/cast/dyncast.
 
232
    static bool classof(const DIEValue *) { return true; }
 
233
 
 
234
#ifndef NDEBUG
 
235
    virtual void print(raw_ostream &O) = 0;
 
236
    void dump();
 
237
#endif
 
238
  };
 
239
 
 
240
  //===--------------------------------------------------------------------===//
 
241
  /// DIEInteger - An integer value DIE.
 
242
  ///
 
243
  class DIEInteger : public DIEValue {
 
244
    uint64_t Integer;
 
245
  public:
 
246
    explicit DIEInteger(uint64_t I) : DIEValue(isInteger), Integer(I) {}
 
247
 
 
248
    /// BestForm - Choose the best form for integer.
 
249
    ///
 
250
    static unsigned BestForm(bool IsSigned, uint64_t Int) {
 
251
      if (IsSigned) {
 
252
        if ((char)Int == (signed)Int)   return dwarf::DW_FORM_data1;
 
253
        if ((short)Int == (signed)Int)  return dwarf::DW_FORM_data2;
 
254
        if ((int)Int == (signed)Int)    return dwarf::DW_FORM_data4;
 
255
      } else {
 
256
        if ((unsigned char)Int == Int)  return dwarf::DW_FORM_data1;
 
257
        if ((unsigned short)Int == Int) return dwarf::DW_FORM_data2;
 
258
        if ((unsigned int)Int == Int)   return dwarf::DW_FORM_data4;
 
259
      }
 
260
      return dwarf::DW_FORM_data8;
 
261
    }
 
262
 
 
263
    /// EmitValue - Emit integer of appropriate size.
 
264
    ///
 
265
    virtual void EmitValue(DwarfPrinter *D, unsigned Form) const;
 
266
 
 
267
    /// SizeOf - Determine size of integer value in bytes.
 
268
    ///
 
269
    virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const;
 
270
 
 
271
 
 
272
    // Implement isa/cast/dyncast.
 
273
    static bool classof(const DIEInteger *) { return true; }
 
274
    static bool classof(const DIEValue *I) { return I->getType() == isInteger; }
 
275
 
 
276
#ifndef NDEBUG
 
277
    virtual void print(raw_ostream &O);
 
278
#endif
 
279
  };
 
280
 
 
281
  //===--------------------------------------------------------------------===//
 
282
  /// DIEString - A string value DIE. This DIE keeps string reference only.
 
283
  ///
 
284
  class DIEString : public DIEValue {
 
285
    const StringRef Str;
 
286
  public:
 
287
    explicit DIEString(const StringRef S) : DIEValue(isString), Str(S) {}
 
288
 
 
289
    /// EmitValue - Emit string value.
 
290
    ///
 
291
    virtual void EmitValue(DwarfPrinter *D, unsigned Form) const;
 
292
 
 
293
    /// SizeOf - Determine size of string value in bytes.
 
294
    ///
 
295
    virtual unsigned SizeOf(const TargetData *, unsigned /*Form*/) const {
 
296
      return Str.size() + sizeof(char); // sizeof('\0');
 
297
    }
 
298
 
 
299
    // Implement isa/cast/dyncast.
 
300
    static bool classof(const DIEString *) { return true; }
 
301
    static bool classof(const DIEValue *S) { return S->getType() == isString; }
 
302
 
 
303
#ifndef NDEBUG
 
304
    virtual void print(raw_ostream &O);
 
305
#endif
 
306
  };
 
307
 
 
308
  //===--------------------------------------------------------------------===//
 
309
  /// DIEDwarfLabel - A Dwarf internal label expression DIE.
 
310
  //
 
311
  class DIEDwarfLabel : public DIEValue {
 
312
    const DWLabel Label;
 
313
  public:
 
314
    explicit DIEDwarfLabel(const DWLabel &L) : DIEValue(isLabel), Label(L) {}
 
315
 
 
316
    /// EmitValue - Emit label value.
 
317
    ///
 
318
    virtual void EmitValue(DwarfPrinter *D, unsigned Form) const;
 
319
 
 
320
    /// SizeOf - Determine size of label value in bytes.
 
321
    ///
 
322
    virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const;
 
323
 
 
324
    // Implement isa/cast/dyncast.
 
325
    static bool classof(const DIEDwarfLabel *)  { return true; }
 
326
    static bool classof(const DIEValue *L) { return L->getType() == isLabel; }
 
327
 
 
328
#ifndef NDEBUG
 
329
    virtual void print(raw_ostream &O);
 
330
#endif
 
331
  };
 
332
 
 
333
  //===--------------------------------------------------------------------===//
 
334
  /// DIEObjectLabel - A label to an object in code or data.
 
335
  //
 
336
  class DIEObjectLabel : public DIEValue {
 
337
    const MCSymbol *Sym;
 
338
  public:
 
339
    explicit DIEObjectLabel(const MCSymbol *S)
 
340
      : DIEValue(isAsIsLabel), Sym(S) {}
 
341
 
 
342
    /// EmitValue - Emit label value.
 
343
    ///
 
344
    virtual void EmitValue(DwarfPrinter *D, unsigned Form) const;
 
345
 
 
346
    /// SizeOf - Determine size of label value in bytes.
 
347
    ///
 
348
    virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const;
 
349
 
 
350
    // Implement isa/cast/dyncast.
 
351
    static bool classof(const DIEObjectLabel *) { return true; }
 
352
    static bool classof(const DIEValue *L) {
 
353
      return L->getType() == isAsIsLabel;
 
354
    }
 
355
 
 
356
#ifndef NDEBUG
 
357
    virtual void print(raw_ostream &O);
 
358
#endif
 
359
  };
 
360
 
 
361
  //===--------------------------------------------------------------------===//
 
362
  /// DIESectionOffset - A section offset DIE.
 
363
  ///
 
364
  class DIESectionOffset : public DIEValue {
 
365
    const DWLabel Label;
 
366
    const DWLabel Section;
 
367
    bool IsEH : 1;
 
368
    bool UseSet : 1;
 
369
  public:
 
370
    DIESectionOffset(const DWLabel &Lab, const DWLabel &Sec,
 
371
                     bool isEH = false, bool useSet = true)
 
372
      : DIEValue(isSectionOffset), Label(Lab), Section(Sec),
 
373
        IsEH(isEH), UseSet(useSet) {}
 
374
 
 
375
    /// EmitValue - Emit section offset.
 
376
    ///
 
377
    virtual void EmitValue(DwarfPrinter *D, unsigned Form) const;
 
378
 
 
379
    /// SizeOf - Determine size of section offset value in bytes.
 
380
    ///
 
381
    virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const;
 
382
 
 
383
    // Implement isa/cast/dyncast.
 
384
    static bool classof(const DIESectionOffset *)  { return true; }
 
385
    static bool classof(const DIEValue *D) {
 
386
      return D->getType() == isSectionOffset;
 
387
    }
 
388
 
 
389
#ifndef NDEBUG
 
390
    virtual void print(raw_ostream &O);
 
391
#endif
 
392
  };
 
393
 
 
394
  //===--------------------------------------------------------------------===//
 
395
  /// DIEDelta - A simple label difference DIE.
 
396
  ///
 
397
  class DIEDelta : public DIEValue {
 
398
    const DWLabel LabelHi;
 
399
    const DWLabel LabelLo;
 
400
  public:
 
401
    DIEDelta(const DWLabel &Hi, const DWLabel &Lo)
 
402
      : DIEValue(isDelta), LabelHi(Hi), LabelLo(Lo) {}
 
403
 
 
404
    /// EmitValue - Emit delta value.
 
405
    ///
 
406
    virtual void EmitValue(DwarfPrinter *D, unsigned Form) const;
 
407
 
 
408
    /// SizeOf - Determine size of delta value in bytes.
 
409
    ///
 
410
    virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const;
 
411
 
 
412
    // Implement isa/cast/dyncast.
 
413
    static bool classof(const DIEDelta *)  { return true; }
 
414
    static bool classof(const DIEValue *D) { return D->getType() == isDelta; }
 
415
 
 
416
#ifndef NDEBUG
 
417
    virtual void print(raw_ostream &O);
 
418
#endif
 
419
  };
 
420
 
 
421
  //===--------------------------------------------------------------------===//
 
422
  /// DIEntry - A pointer to another debug information entry.  An instance of
 
423
  /// this class can also be used as a proxy for a debug information entry not
 
424
  /// yet defined (ie. types.)
 
425
  class DIEEntry : public DIEValue {
 
426
    DIE *Entry;
 
427
  public:
 
428
    explicit DIEEntry(DIE *E) : DIEValue(isEntry), Entry(E) {}
 
429
 
 
430
    DIE *getEntry() const { return Entry; }
 
431
    void setEntry(DIE *E) { Entry = E; }
 
432
 
 
433
    /// EmitValue - Emit debug information entry offset.
 
434
    ///
 
435
    virtual void EmitValue(DwarfPrinter *D, unsigned Form) const;
 
436
 
 
437
    /// SizeOf - Determine size of debug information entry in bytes.
 
438
    ///
 
439
    virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const {
 
440
      return sizeof(int32_t);
 
441
    }
 
442
 
 
443
    // Implement isa/cast/dyncast.
 
444
    static bool classof(const DIEEntry *)  { return true; }
 
445
    static bool classof(const DIEValue *E) { return E->getType() == isEntry; }
 
446
 
 
447
#ifndef NDEBUG
 
448
    virtual void print(raw_ostream &O);
 
449
#endif
 
450
  };
 
451
 
 
452
  //===--------------------------------------------------------------------===//
 
453
  /// DIEBlock - A block of values.  Primarily used for location expressions.
 
454
  //
 
455
  class DIEBlock : public DIEValue, public DIE {
 
456
    unsigned Size;                // Size in bytes excluding size header.
 
457
  public:
 
458
    DIEBlock()
 
459
      : DIEValue(isBlock), DIE(0), Size(0) {}
 
460
    virtual ~DIEBlock() {}
 
461
 
 
462
    /// ComputeSize - calculate the size of the block.
 
463
    ///
 
464
    unsigned ComputeSize(const TargetData *TD);
 
465
 
 
466
    /// BestForm - Choose the best form for data.
 
467
    ///
 
468
    unsigned BestForm() const {
 
469
      if ((unsigned char)Size == Size)  return dwarf::DW_FORM_block1;
 
470
      if ((unsigned short)Size == Size) return dwarf::DW_FORM_block2;
 
471
      if ((unsigned int)Size == Size)   return dwarf::DW_FORM_block4;
 
472
      return dwarf::DW_FORM_block;
 
473
    }
 
474
 
 
475
    /// EmitValue - Emit block data.
 
476
    ///
 
477
    virtual void EmitValue(DwarfPrinter *D, unsigned Form) const;
 
478
 
 
479
    /// SizeOf - Determine size of block data in bytes.
 
480
    ///
 
481
    virtual unsigned SizeOf(const TargetData *TD, unsigned Form) const;
 
482
 
 
483
    // Implement isa/cast/dyncast.
 
484
    static bool classof(const DIEBlock *)  { return true; }
 
485
    static bool classof(const DIEValue *E) { return E->getType() == isBlock; }
 
486
 
 
487
#ifndef NDEBUG
 
488
    virtual void print(raw_ostream &O);
 
489
#endif
 
490
  };
 
491
 
 
492
} // end llvm namespace
 
493
 
 
494
#endif