← 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/ELF.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/ELF.h
 
1
//===-- lib/CodeGen/ELF.h - ELF constants and data structures ---*- 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
// This header contains common, non-processor-specific data structures and
 
11
// constants for the ELF file format.
 
12
//
 
13
// The details of the ELF32 bits in this file are largely based on the Tool
 
14
// Interface Standard (TIS) Executable and Linking Format (ELF) Specification
 
15
// Version 1.2, May 1995. The ELF64 is based on HP/Intel definition of the
 
16
// ELF-64 object file format document, Version 1.5 Draft 2 May 27, 1998
 
17
//
 
18
//===----------------------------------------------------------------------===//
 
19
 
 
20
#ifndef CODEGEN_ELF_H
 
21
#define CODEGEN_ELF_H
 
22
 
 
23
#include "llvm/CodeGen/BinaryObject.h"
 
24
#include "llvm/CodeGen/MachineRelocation.h"
 
25
#include "llvm/System/DataTypes.h"
 
26
 
 
27
namespace llvm {
 
28
  class GlobalValue;
 
29
 
 
30
  // Identification Indexes
 
31
  enum {
 
32
    EI_MAG0 = 0,
 
33
    EI_MAG1 = 1,
 
34
    EI_MAG2 = 2,
 
35
    EI_MAG3 = 3
 
36
  };
 
37
 
 
38
  // File types
 
39
  enum {
 
40
    ET_NONE   = 0,      // No file type
 
41
    ET_REL    = 1,      // Relocatable file
 
42
    ET_EXEC   = 2,      // Executable file
 
43
    ET_DYN    = 3,      // Shared object file
 
44
    ET_CORE   = 4,      // Core file
 
45
    ET_LOPROC = 0xff00, // Beginning of processor-specific codes
 
46
    ET_HIPROC = 0xffff  // Processor-specific
 
47
  };
 
48
 
 
49
  // Versioning
 
50
  enum {
 
51
    EV_NONE = 0,
 
52
    EV_CURRENT = 1
 
53
  };
 
54
 
 
55
  /// ELFSym - This struct contains information about each symbol that is
 
56
  /// added to logical symbol table for the module.  This is eventually
 
57
  /// turned into a real symbol table in the file.
 
58
  struct ELFSym {
 
59
 
 
60
    // ELF symbols are related to llvm ones by being one of the two llvm
 
61
    // types, for the other ones (section, file, func) a null pointer is
 
62
    // assumed by default.
 
63
    union {
 
64
      const GlobalValue *GV;  // If this is a pointer to a GV
 
65
      const char *Ext;        // If this is a pointer to a named symbol
 
66
    } Source;
 
67
 
 
68
    // Describes from which source type this ELF symbol comes from,
 
69
    // they can be GlobalValue, ExternalSymbol or neither.
 
70
    enum {
 
71
      isGV,      // The Source.GV field is valid.
 
72
      isExtSym,  // The Source.ExtSym field is valid.
 
73
      isOther    // Not a GlobalValue or External Symbol
 
74
    };
 
75
    unsigned SourceType;
 
76
 
 
77
    bool isGlobalValue() const { return SourceType == isGV; }
 
78
    bool isExternalSym() const { return SourceType == isExtSym; }
 
79
 
 
80
    // getGlobalValue - If this is a global value which originated the
 
81
    // elf symbol, return a reference to it.
 
82
    const GlobalValue *getGlobalValue() const {
 
83
      assert(SourceType == isGV && "This is not a global value");
 
84
      return Source.GV;
 
85
    }
 
86
 
 
87
    // getExternalSym - If this is an external symbol which originated the
 
88
    // elf symbol, return a reference to it.
 
89
    const char *getExternalSymbol() const {
 
90
      assert(SourceType == isExtSym && "This is not an external symbol");
 
91
      return Source.Ext;
 
92
    }
 
93
 
 
94
    // getGV - From a global value return a elf symbol to represent it
 
95
    static ELFSym *getGV(const GlobalValue *GV, unsigned Bind,
 
96
                         unsigned Type, unsigned Visibility) {
 
97
      ELFSym *Sym = new ELFSym();
 
98
      Sym->Source.GV = GV;
 
99
      Sym->setBind(Bind);
 
100
      Sym->setType(Type);
 
101
      Sym->setVisibility(Visibility);
 
102
      Sym->SourceType = isGV;
 
103
      return Sym;
 
104
    }
 
105
 
 
106
    // getExtSym - Create and return an elf symbol to represent an
 
107
    // external symbol
 
108
    static ELFSym *getExtSym(const char *Ext) {
 
109
      ELFSym *Sym = new ELFSym();
 
110
      Sym->Source.Ext = Ext;
 
111
      Sym->setBind(STB_GLOBAL);
 
112
      Sym->setType(STT_NOTYPE);
 
113
      Sym->setVisibility(STV_DEFAULT);
 
114
      Sym->SourceType = isExtSym;
 
115
      return Sym;
 
116
    }
 
117
 
 
118
    // getSectionSym - Returns a elf symbol to represent an elf section
 
119
    static ELFSym *getSectionSym() {
 
120
      ELFSym *Sym = new ELFSym();
 
121
      Sym->setBind(STB_LOCAL);
 
122
      Sym->setType(STT_SECTION);
 
123
      Sym->setVisibility(STV_DEFAULT);
 
124
      Sym->SourceType = isOther;
 
125
      return Sym;
 
126
    }
 
127
 
 
128
    // getFileSym - Returns a elf symbol to represent the module identifier
 
129
    static ELFSym *getFileSym() {
 
130
      ELFSym *Sym = new ELFSym();
 
131
      Sym->setBind(STB_LOCAL);
 
132
      Sym->setType(STT_FILE);
 
133
      Sym->setVisibility(STV_DEFAULT);
 
134
      Sym->SectionIdx = 0xfff1;  // ELFSection::SHN_ABS;
 
135
      Sym->SourceType = isOther;
 
136
      return Sym;
 
137
    }
 
138
 
 
139
    // getUndefGV - Returns a STT_NOTYPE symbol
 
140
    static ELFSym *getUndefGV(const GlobalValue *GV, unsigned Bind) {
 
141
      ELFSym *Sym = new ELFSym();
 
142
      Sym->Source.GV = GV;
 
143
      Sym->setBind(Bind);
 
144
      Sym->setType(STT_NOTYPE);
 
145
      Sym->setVisibility(STV_DEFAULT);
 
146
      Sym->SectionIdx = 0;  //ELFSection::SHN_UNDEF;
 
147
      Sym->SourceType = isGV;
 
148
      return Sym;
 
149
    }
 
150
 
 
151
    // ELF specific fields
 
152
    unsigned NameIdx;         // Index in .strtab of name, once emitted.
 
153
    uint64_t Value;
 
154
    unsigned Size;
 
155
    uint8_t Info;
 
156
    uint8_t Other;
 
157
    unsigned short SectionIdx;
 
158
 
 
159
    // Symbol index into the Symbol table
 
160
    unsigned SymTabIdx;
 
161
 
 
162
    enum {
 
163
      STB_LOCAL = 0,  // Local sym, not visible outside obj file containing def
 
164
      STB_GLOBAL = 1, // Global sym, visible to all object files being combined
 
165
      STB_WEAK = 2    // Weak symbol, like global but lower-precedence
 
166
    };
 
167
 
 
168
    enum {
 
169
      STT_NOTYPE = 0,  // Symbol's type is not specified
 
170
      STT_OBJECT = 1,  // Symbol is a data object (variable, array, etc.)
 
171
      STT_FUNC = 2,    // Symbol is executable code (function, etc.)
 
172
      STT_SECTION = 3, // Symbol refers to a section
 
173
      STT_FILE = 4     // Local, absolute symbol that refers to a file
 
174
    };
 
175
 
 
176
    enum {
 
177
      STV_DEFAULT = 0,  // Visibility is specified by binding type
 
178
      STV_INTERNAL = 1, // Defined by processor supplements
 
179
      STV_HIDDEN = 2,   // Not visible to other components
 
180
      STV_PROTECTED = 3 // Visible in other components but not preemptable
 
181
    };
 
182
 
 
183
    ELFSym() : SourceType(isOther), NameIdx(0), Value(0),
 
184
               Size(0), Info(0), Other(STV_DEFAULT), SectionIdx(0),
 
185
               SymTabIdx(0) {}
 
186
 
 
187
    unsigned getBind() const { return (Info >> 4) & 0xf; }
 
188
    unsigned getType() const { return Info & 0xf; }
 
189
    bool isLocalBind() const { return getBind() == STB_LOCAL; }
 
190
    bool isFileType() const { return getType() == STT_FILE; }
 
191
 
 
192
    void setBind(unsigned X) {
 
193
      assert(X == (X & 0xF) && "Bind value out of range!");
 
194
      Info = (Info & 0x0F) | (X << 4);
 
195
    }
 
196
 
 
197
    void setType(unsigned X) {
 
198
      assert(X == (X & 0xF) && "Type value out of range!");
 
199
      Info = (Info & 0xF0) | X;
 
200
    }
 
201
 
 
202
    void setVisibility(unsigned V) {
 
203
      assert(V == (V & 0x3) && "Visibility value out of range!");
 
204
      Other = V;
 
205
    }
 
206
  };
 
207
 
 
208
  /// ELFSection - This struct contains information about each section that is
 
209
  /// emitted to the file.  This is eventually turned into the section header
 
210
  /// table at the end of the file.
 
211
  class ELFSection : public BinaryObject {
 
212
    public:
 
213
    // ELF specific fields
 
214
    unsigned NameIdx;   // sh_name - .shstrtab idx of name, once emitted.
 
215
    unsigned Type;      // sh_type - Section contents & semantics 
 
216
    unsigned Flags;     // sh_flags - Section flags.
 
217
    uint64_t Addr;      // sh_addr - The mem addr this section is in.
 
218
    unsigned Offset;    // sh_offset - Offset from the file start
 
219
    unsigned Size;      // sh_size - The section size.
 
220
    unsigned Link;      // sh_link - Section header table index link.
 
221
    unsigned Info;      // sh_info - Auxillary information.
 
222
    unsigned Align;     // sh_addralign - Alignment of section.
 
223
    unsigned EntSize;   // sh_entsize - Size of entries in the section e
 
224
 
 
225
    // Section Header Flags
 
226
    enum {
 
227
      SHF_WRITE            = 1 << 0, // Writable
 
228
      SHF_ALLOC            = 1 << 1, // Mapped into the process addr space
 
229
      SHF_EXECINSTR        = 1 << 2, // Executable
 
230
      SHF_MERGE            = 1 << 4, // Might be merged if equal
 
231
      SHF_STRINGS          = 1 << 5, // Contains null-terminated strings
 
232
      SHF_INFO_LINK        = 1 << 6, // 'sh_info' contains SHT index
 
233
      SHF_LINK_ORDER       = 1 << 7, // Preserve order after combining
 
234
      SHF_OS_NONCONFORMING = 1 << 8, // nonstandard OS support required
 
235
      SHF_GROUP            = 1 << 9, // Section is a member of a group
 
236
      SHF_TLS              = 1 << 10 // Section holds thread-local data
 
237
    };
 
238
 
 
239
    // Section Types
 
240
    enum {
 
241
      SHT_NULL     = 0,  // No associated section (inactive entry).
 
242
      SHT_PROGBITS = 1,  // Program-defined contents.
 
243
      SHT_SYMTAB   = 2,  // Symbol table.
 
244
      SHT_STRTAB   = 3,  // String table.
 
245
      SHT_RELA     = 4,  // Relocation entries; explicit addends.
 
246
      SHT_HASH     = 5,  // Symbol hash table.
 
247
      SHT_DYNAMIC  = 6,  // Information for dynamic linking.
 
248
      SHT_NOTE     = 7,  // Information about the file.
 
249
      SHT_NOBITS   = 8,  // Data occupies no space in the file.
 
250
      SHT_REL      = 9,  // Relocation entries; no explicit addends.
 
251
      SHT_SHLIB    = 10, // Reserved.
 
252
      SHT_DYNSYM   = 11, // Symbol table.
 
253
      SHT_LOPROC   = 0x70000000, // Lowest processor arch-specific type.
 
254
      SHT_HIPROC   = 0x7fffffff, // Highest processor arch-specific type.
 
255
      SHT_LOUSER   = 0x80000000, // Lowest type reserved for applications.
 
256
      SHT_HIUSER   = 0xffffffff  // Highest type reserved for applications.
 
257
    };
 
258
 
 
259
    // Special section indices.
 
260
    enum {
 
261
      SHN_UNDEF     = 0,      // Undefined, missing, irrelevant
 
262
      SHN_LORESERVE = 0xff00, // Lowest reserved index
 
263
      SHN_LOPROC    = 0xff00, // Lowest processor-specific index
 
264
      SHN_HIPROC    = 0xff1f, // Highest processor-specific index
 
265
      SHN_ABS       = 0xfff1, // Symbol has absolute value; no relocation
 
266
      SHN_COMMON    = 0xfff2, // FORTRAN COMMON or C external global variables
 
267
      SHN_HIRESERVE = 0xffff  // Highest reserved index
 
268
    };
 
269
 
 
270
    /// SectionIdx - The number of the section in the Section Table.
 
271
    unsigned short SectionIdx;
 
272
 
 
273
    /// Sym - The symbol to represent this section if it has one.
 
274
    ELFSym *Sym;
 
275
 
 
276
    /// getSymIndex - Returns the symbol table index of the symbol
 
277
    /// representing this section.
 
278
    unsigned getSymbolTableIndex() const {
 
279
      assert(Sym && "section not present in the symbol table");
 
280
      return Sym->SymTabIdx;
 
281
    }
 
282
 
 
283
    ELFSection(const std::string &name, bool isLittleEndian, bool is64Bit)
 
284
      : BinaryObject(name, isLittleEndian, is64Bit), Type(0), Flags(0), Addr(0),
 
285
        Offset(0), Size(0), Link(0), Info(0), Align(0), EntSize(0), Sym(0) {}
 
286
  };
 
287
 
 
288
  /// ELFRelocation - This class contains all the information necessary to
 
289
  /// to generate any 32-bit or 64-bit ELF relocation entry.
 
290
  class ELFRelocation {
 
291
    uint64_t r_offset;    // offset in the section of the object this applies to
 
292
    uint32_t r_symidx;    // symbol table index of the symbol to use
 
293
    uint32_t r_type;      // machine specific relocation type
 
294
    int64_t  r_add;       // explicit relocation addend
 
295
    bool     r_rela;      // if true then the addend is part of the entry
 
296
                          // otherwise the addend is at the location specified
 
297
                          // by r_offset
 
298
  public:
 
299
    uint64_t getInfo(bool is64Bit) const {
 
300
      if (is64Bit)
 
301
        return ((uint64_t)r_symidx << 32) + ((uint64_t)r_type & 0xFFFFFFFFL);
 
302
      else
 
303
        return (r_symidx << 8)  + (r_type & 0xFFL);
 
304
    }
 
305
 
 
306
    uint64_t getOffset() const { return r_offset; }
 
307
    int64_t getAddend() const { return r_add; }
 
308
 
 
309
    ELFRelocation(uint64_t off, uint32_t sym, uint32_t type,
 
310
                  bool rela = true, int64_t addend = 0) :
 
311
      r_offset(off), r_symidx(sym), r_type(type),
 
312
      r_add(addend), r_rela(rela) {}
 
313
  };
 
314
 
 
315
} // end namespace llvm
 
316
 
 
317
#endif