← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/Target/TargetLoweringObjectFile.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/include/llvm/Target/TargetLoweringObjectFile.h
 
1
//===-- llvm/Target/TargetLoweringObjectFile.h - Object Info ----*- 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 file implements classes used to handle lowerings specific to common
 
11
// object file formats.
 
12
//
 
13
//===----------------------------------------------------------------------===//
 
14
 
 
15
#ifndef LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H
 
16
#define LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H
 
17
 
 
18
#include "llvm/ADT/StringRef.h"
 
19
#include "llvm/MC/SectionKind.h"
 
20
 
 
21
namespace llvm {
 
22
  class MachineModuleInfo;
 
23
  class Mangler;
 
24
  class MCAsmInfo;
 
25
  class MCExpr;
 
26
  class MCSection;
 
27
  class MCSectionMachO;
 
28
  class MCSymbol;
 
29
  class MCContext;
 
30
  class GlobalValue;
 
31
  class TargetMachine;
 
32
  
 
33
class TargetLoweringObjectFile {
 
34
  MCContext *Ctx;
 
35
  
 
36
  TargetLoweringObjectFile(const TargetLoweringObjectFile&); // DO NOT IMPLEMENT
 
37
  void operator=(const TargetLoweringObjectFile&);           // DO NOT IMPLEMENT
 
38
protected:
 
39
  
 
40
  TargetLoweringObjectFile();
 
41
  
 
42
  /// TextSection - Section directive for standard text.
 
43
  ///
 
44
  const MCSection *TextSection;
 
45
  
 
46
  /// DataSection - Section directive for standard data.
 
47
  ///
 
48
  const MCSection *DataSection;
 
49
  
 
50
  /// BSSSection - Section that is default initialized to zero.
 
51
  const MCSection *BSSSection;
 
52
  
 
53
  /// ReadOnlySection - Section that is readonly and can contain arbitrary
 
54
  /// initialized data.  Targets are not required to have a readonly section.
 
55
  /// If they don't, various bits of code will fall back to using the data
 
56
  /// section for constants.
 
57
  const MCSection *ReadOnlySection;
 
58
  
 
59
  /// StaticCtorSection - This section contains the static constructor pointer
 
60
  /// list.
 
61
  const MCSection *StaticCtorSection;
 
62
 
 
63
  /// StaticDtorSection - This section contains the static destructor pointer
 
64
  /// list.
 
65
  const MCSection *StaticDtorSection;
 
66
  
 
67
  /// LSDASection - If exception handling is supported by the target, this is
 
68
  /// the section the Language Specific Data Area information is emitted to.
 
69
  const MCSection *LSDASection;
 
70
  
 
71
  /// EHFrameSection - If exception handling is supported by the target, this is
 
72
  /// the section the EH Frame is emitted to.
 
73
  const MCSection *EHFrameSection;
 
74
  
 
75
  // Dwarf sections for debug info.  If a target supports debug info, these must
 
76
  // be set.
 
77
  const MCSection *DwarfAbbrevSection;
 
78
  const MCSection *DwarfInfoSection;
 
79
  const MCSection *DwarfLineSection;
 
80
  const MCSection *DwarfFrameSection;
 
81
  const MCSection *DwarfPubNamesSection;
 
82
  const MCSection *DwarfPubTypesSection;
 
83
  const MCSection *DwarfDebugInlineSection;
 
84
  const MCSection *DwarfStrSection;
 
85
  const MCSection *DwarfLocSection;
 
86
  const MCSection *DwarfARangesSection;
 
87
  const MCSection *DwarfRangesSection;
 
88
  const MCSection *DwarfMacroInfoSection;
 
89
  
 
90
public:
 
91
  
 
92
  MCContext &getContext() const { return *Ctx; }
 
93
  
 
94
 
 
95
  virtual ~TargetLoweringObjectFile();
 
96
  
 
97
  /// Initialize - this method must be called before any actual lowering is
 
98
  /// done.  This specifies the current context for codegen, and gives the
 
99
  /// lowering implementations a chance to set up their default sections.
 
100
  virtual void Initialize(MCContext &ctx, const TargetMachine &TM) {
 
101
    Ctx = &ctx;
 
102
  }
 
103
  
 
104
  
 
105
  const MCSection *getTextSection() const { return TextSection; }
 
106
  const MCSection *getDataSection() const { return DataSection; }
 
107
  const MCSection *getBSSSection() const { return BSSSection; }
 
108
  const MCSection *getStaticCtorSection() const { return StaticCtorSection; }
 
109
  const MCSection *getStaticDtorSection() const { return StaticDtorSection; }
 
110
  const MCSection *getLSDASection() const { return LSDASection; }
 
111
  const MCSection *getEHFrameSection() const { return EHFrameSection; }
 
112
  const MCSection *getDwarfAbbrevSection() const { return DwarfAbbrevSection; }
 
113
  const MCSection *getDwarfInfoSection() const { return DwarfInfoSection; }
 
114
  const MCSection *getDwarfLineSection() const { return DwarfLineSection; }
 
115
  const MCSection *getDwarfFrameSection() const { return DwarfFrameSection; }
 
116
  const MCSection *getDwarfPubNamesSection() const{return DwarfPubNamesSection;}
 
117
  const MCSection *getDwarfPubTypesSection() const{return DwarfPubTypesSection;}
 
118
  const MCSection *getDwarfDebugInlineSection() const {
 
119
    return DwarfDebugInlineSection;
 
120
  }
 
121
  const MCSection *getDwarfStrSection() const { return DwarfStrSection; }
 
122
  const MCSection *getDwarfLocSection() const { return DwarfLocSection; }
 
123
  const MCSection *getDwarfARangesSection() const { return DwarfARangesSection;}
 
124
  const MCSection *getDwarfRangesSection() const { return DwarfRangesSection; }
 
125
  const MCSection *getDwarfMacroInfoSection() const {
 
126
    return DwarfMacroInfoSection;
 
127
  }
 
128
  
 
129
  /// shouldEmitUsedDirectiveFor - This hook allows targets to selectively
 
130
  /// decide not to emit the UsedDirective for some symbols in llvm.used.
 
131
  /// FIXME: REMOVE this (rdar://7071300)
 
132
  virtual bool shouldEmitUsedDirectiveFor(const GlobalValue *GV,
 
133
                                          Mangler *) const {
 
134
    return GV != 0;
 
135
  }
 
136
  
 
137
  /// getSectionForConstant - Given a constant with the SectionKind, return a
 
138
  /// section that it should be placed in.
 
139
  virtual const MCSection *getSectionForConstant(SectionKind Kind) const;
 
140
  
 
141
  /// getKindForGlobal - Classify the specified global variable into a set of
 
142
  /// target independent categories embodied in SectionKind.
 
143
  static SectionKind getKindForGlobal(const GlobalValue *GV,
 
144
                                      const TargetMachine &TM);
 
145
  
 
146
  /// SectionForGlobal - This method computes the appropriate section to emit
 
147
  /// the specified global variable or function definition.  This should not
 
148
  /// be passed external (or available externally) globals.
 
149
  const MCSection *SectionForGlobal(const GlobalValue *GV,
 
150
                                    SectionKind Kind, Mangler *Mang,
 
151
                                    const TargetMachine &TM) const;
 
152
  
 
153
  /// SectionForGlobal - This method computes the appropriate section to emit
 
154
  /// the specified global variable or function definition.  This should not
 
155
  /// be passed external (or available externally) globals.
 
156
  const MCSection *SectionForGlobal(const GlobalValue *GV,
 
157
                                    Mangler *Mang,
 
158
                                    const TargetMachine &TM) const {
 
159
    return SectionForGlobal(GV, getKindForGlobal(GV, TM), Mang, TM);
 
160
  }
 
161
  
 
162
  
 
163
  
 
164
  /// getExplicitSectionGlobal - Targets should implement this method to assign
 
165
  /// a section to globals with an explicit section specfied.  The
 
166
  /// implementation of this method can assume that GV->hasSection() is true.
 
167
  virtual const MCSection *
 
168
  getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind, 
 
169
                           Mangler *Mang, const TargetMachine &TM) const = 0;
 
170
  
 
171
  /// getSpecialCasedSectionGlobals - Allow the target to completely override
 
172
  /// section assignment of a global.
 
173
  virtual const MCSection *
 
174
  getSpecialCasedSectionGlobals(const GlobalValue *GV, Mangler *Mang,
 
175
                                SectionKind Kind) const {
 
176
    return 0;
 
177
  }
 
178
  
 
179
  /// getSymbolForDwarfGlobalReference - Return an MCExpr to use for a reference
 
180
  /// to the specified global variable from exception handling information.
 
181
  ///
 
182
  virtual const MCExpr *
 
183
  getSymbolForDwarfGlobalReference(const GlobalValue *GV, Mangler *Mang,
 
184
                              MachineModuleInfo *MMI, unsigned Encoding) const;
 
185
 
 
186
  virtual const MCExpr *
 
187
  getSymbolForDwarfReference(const MCSymbol *Sym, MachineModuleInfo *MMI,
 
188
                             unsigned Encoding) const;
 
189
 
 
190
  virtual unsigned getPersonalityEncoding() const;
 
191
  virtual unsigned getLSDAEncoding() const;
 
192
  virtual unsigned getFDEEncoding() const;
 
193
  virtual unsigned getTTypeEncoding() const;
 
194
 
 
195
protected:
 
196
  virtual const MCSection *
 
197
  SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
 
198
                         Mangler *Mang, const TargetMachine &TM) const;
 
199
};
 
200
 
 
201
} // end namespace llvm
 
202
 
 
203
#endif