← Back to branch summary

~ubuntu-branches/ubuntu/vivid/clamav/vivid

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/CodeGen/MachineModuleInfo.h

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman, Sebastian Andrzej Siewior, Andreas Cadhalpun, Scott Kitterman, Javier Fernández-Sanguino
  • Date: 2015-01-28 00:25:13 UTC
  • mfrom: (0.48.14 sid)
  • Revision ID: package-import@ubuntu.com-20150128002513-lil2oi74cooy4lzr
Tags: 0.98.6+dfsg-1
http://bugs.debian.org/774686
http://bugs.debian.org/767350
http://bugs.debian.org/775400
http://bugs.debian.org/767353
http://bugs.debian.org/773563
[ Sebastian Andrzej Siewior ]
* update "fix-ssize_t-size_t-off_t-printf-modifier", include of misc.h was
  missing but was pulled in via the systemd patch.
* Don't leak return codes from libmspack to clamav API. (Closes: #774686).

[ Andreas Cadhalpun ]
* Add patch to avoid emitting incremental progress messages when not
  outputting to a terminal. (Closes: #767350)
* Update lintian-overrides for unused-file-paragraph-in-dep5-copyright.
* clamav-base.postinst: always chown /var/log/clamav and /var/lib/clamav
  to clamav:clamav, not only on fresh installations. (Closes: #775400)
* Adapt the clamav-daemon and clamav-freshclam logrotate scripts,
  so that they correctly work under systemd.
* Move the PidFile variable from the clamd/freshclam configuration files
  to the init scripts. This makes the init scripts more robust against
  misconfiguration and avoids error messages with systemd. (Closes: #767353)
* debian/copyright: drop files from Files-Excluded only present in github
  tarballs
* Drop Workaround-a-bug-in-libc-on-Hurd.patch, because hurd got fixed.
  (see #752237)
* debian/rules: Remove useless --with-system-tommath --without-included-ltdl
  configure options.

[ Scott Kitterman ]
* Stop stripping llvm when repacking the tarball as the system llvm on some
  releases is too old to use
* New upstream bugfix release
  - Library shared object revisions.
  - Includes a patch from Sebastian Andrzej Siewior making ClamAV pid files
    compatible with systemd.
  - Fix a heap out of bounds condition with crafted Yoda's crypter files.
    This issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted mew packer files. This
    issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted upx packer files. This
    issue was discovered by Kevin Szkudlapski of Quarkslab.
  - Fix a heap out of bounds condition with crafted upack packer files. This
    issue was discovered by Sebastian Andrzej Siewior. CVE-2014-9328.
  - Compensate a crash due to incorrect compiler optimization when handling
    crafted petite packer files. This issue was discovered by Sebastian
    Andrzej Siewior.
* Update lintian override for embedded zlib to match new so version

[ Javier Fernández-Sanguino ]
* Updated Spanish Debconf template translation (Closes: #773563)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm/CodeGen/MachineModuleInfo.h
 
1
//===-- llvm/CodeGen/MachineModuleInfo.h ------------------------*- 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
// Collect meta information for a module.  This information should be in a
 
11
// neutral form that can be used by different debugging and exception handling
 
12
// schemes.
 
13
//
 
14
// The organization of information is primarily clustered around the source
 
15
// compile units.  The main exception is source line correspondence where
 
16
// inlining may interleave code from various compile units.
 
17
//
 
18
// The following information can be retrieved from the MachineModuleInfo.
 
19
//
 
20
//  -- Source directories - Directories are uniqued based on their canonical
 
21
//     string and assigned a sequential numeric ID (base 1.)
 
22
//  -- Source files - Files are also uniqued based on their name and directory
 
23
//     ID.  A file ID is sequential number (base 1.)
 
24
//  -- Source line correspondence - A vector of file ID, line#, column# triples.
 
25
//     A DEBUG_LOCATION instruction is generated  by the DAG Legalizer
 
26
//     corresponding to each entry in the source line list.  This allows a debug
 
27
//     emitter to generate labels referenced by debug information tables.
 
28
//
 
29
//===----------------------------------------------------------------------===//
 
30
 
 
31
#ifndef LLVM_CODEGEN_MACHINEMODULEINFO_H
 
32
#define LLVM_CODEGEN_MACHINEMODULEINFO_H
 
33
 
 
34
#include "llvm/Pass.h"
 
35
#include "llvm/GlobalValue.h"
 
36
#include "llvm/Metadata.h"
 
37
#include "llvm/CodeGen/MachineLocation.h"
 
38
#include "llvm/MC/MCContext.h"
 
39
#include "llvm/Support/Dwarf.h"
 
40
#include "llvm/Support/DebugLoc.h"
 
41
#include "llvm/Support/ValueHandle.h"
 
42
#include "llvm/System/DataTypes.h"
 
43
#include "llvm/ADT/DenseMap.h"
 
44
#include "llvm/ADT/PointerIntPair.h"
 
45
#include "llvm/ADT/SmallPtrSet.h"
 
46
#include "llvm/ADT/SmallVector.h"
 
47
 
 
48
namespace llvm {
 
49
 
 
50
//===----------------------------------------------------------------------===//
 
51
// Forward declarations.
 
52
class Constant;
 
53
class GlobalVariable;
 
54
class MDNode;
 
55
class MachineBasicBlock;
 
56
class MachineFunction;
 
57
class Module;
 
58
class PointerType;
 
59
class StructType;
 
60
  
 
61
/// MachineModuleInfoImpl - This class can be derived from and used by targets
 
62
/// to hold private target-specific information for each Module.  Objects of
 
63
/// type are accessed/created with MMI::getInfo and destroyed when the
 
64
/// MachineModuleInfo is destroyed.
 
65
class MachineModuleInfoImpl {
 
66
public:
 
67
  typedef PointerIntPair<MCSymbol*, 1, bool> StubValueTy;
 
68
  virtual ~MachineModuleInfoImpl();
 
69
  typedef std::vector<std::pair<MCSymbol*, StubValueTy> > SymbolListTy;
 
70
protected:
 
71
  static SymbolListTy GetSortedStubs(const DenseMap<MCSymbol*, StubValueTy>&);
 
72
};
 
73
  
 
74
  
 
75
 
 
76
//===----------------------------------------------------------------------===//
 
77
/// LandingPadInfo - This structure is used to retain landing pad info for
 
78
/// the current function.
 
79
///
 
80
struct LandingPadInfo {
 
81
  MachineBasicBlock *LandingPadBlock;    // Landing pad block.
 
82
  SmallVector<MCSymbol*, 1> BeginLabels; // Labels prior to invoke.
 
83
  SmallVector<MCSymbol*, 1> EndLabels;   // Labels after invoke.
 
84
  MCSymbol *LandingPadLabel;             // Label at beginning of landing pad.
 
85
  const Function *Personality;           // Personality function.
 
86
  std::vector<int> TypeIds;              // List of type ids (filters negative)
 
87
 
 
88
  explicit LandingPadInfo(MachineBasicBlock *MBB)
 
89
    : LandingPadBlock(MBB), LandingPadLabel(0), Personality(0) {}
 
90
};
 
91
 
 
92
class MMIAddrLabelMap;
 
93
  
 
94
//===----------------------------------------------------------------------===//
 
95
/// MachineModuleInfo - This class contains meta information specific to a
 
96
/// module.  Queries can be made by different debugging and exception handling 
 
97
/// schemes and reformated for specific use.
 
98
///
 
99
class MachineModuleInfo : public ImmutablePass {
 
100
  /// Context - This is the MCContext used for the entire code generator.
 
101
  MCContext Context;
 
102
  
 
103
  /// TheModule - This is the LLVM Module being worked on.
 
104
  const Module *TheModule;
 
105
  
 
106
  /// ObjFileMMI - This is the object-file-format-specific implementation of
 
107
  /// MachineModuleInfoImpl, which lets targets accumulate whatever info they
 
108
  /// want.
 
109
  MachineModuleInfoImpl *ObjFileMMI;
 
110
 
 
111
  // FrameMoves - List of moves done by a function's prolog.  Used to construct
 
112
  // frame maps by debug and exception handling consumers.
 
113
  std::vector<MachineMove> FrameMoves;
 
114
  
 
115
  // LandingPads - List of LandingPadInfo describing the landing pad information
 
116
  // in the current function.
 
117
  std::vector<LandingPadInfo> LandingPads;
 
118
 
 
119
  // Map of invoke call site index values to associated begin EH_LABEL for
 
120
  // the current function.
 
121
  DenseMap<MCSymbol*, unsigned> CallSiteMap;
 
122
 
 
123
  // The current call site index being processed, if any. 0 if none.
 
124
  unsigned CurCallSite;
 
125
 
 
126
  // TypeInfos - List of C++ TypeInfo used in the current function.
 
127
  //
 
128
  std::vector<const GlobalVariable *> TypeInfos;
 
129
 
 
130
  // FilterIds - List of typeids encoding filters used in the current function.
 
131
  //
 
132
  std::vector<unsigned> FilterIds;
 
133
 
 
134
  // FilterEnds - List of the indices in FilterIds corresponding to filter
 
135
  // terminators.
 
136
  //
 
137
  std::vector<unsigned> FilterEnds;
 
138
 
 
139
  // Personalities - Vector of all personality functions ever seen. Used to emit
 
140
  // common EH frames.
 
141
  std::vector<const Function *> Personalities;
 
142
 
 
143
  /// UsedFunctions - The functions in the @llvm.used list in a more easily
 
144
  /// searchable format.  This does not include the functions in
 
145
  /// llvm.compiler.used.
 
146
  SmallPtrSet<const Function *, 32> UsedFunctions;
 
147
 
 
148
  
 
149
  /// AddrLabelSymbols - This map keeps track of which symbol is being used for
 
150
  /// the specified basic block's address of label.
 
151
  MMIAddrLabelMap *AddrLabelSymbols;
 
152
  
 
153
  bool CallsEHReturn;
 
154
  bool CallsUnwindInit;
 
155
 
 
156
  /// DbgInfoAvailable - True if debugging information is available
 
157
  /// in this module.
 
158
  bool DbgInfoAvailable;
 
159
 
 
160
public:
 
161
  static char ID; // Pass identification, replacement for typeid
 
162
 
 
163
  typedef std::pair<unsigned, DebugLoc> UnsignedDebugLocPair;
 
164
  typedef SmallVector<std::pair<TrackingVH<MDNode>, UnsignedDebugLocPair>, 4>
 
165
    VariableDbgInfoMapTy;
 
166
  VariableDbgInfoMapTy VariableDbgInfo;
 
167
 
 
168
  MachineModuleInfo();  // DUMMY CONSTRUCTOR, DO NOT CALL.
 
169
  MachineModuleInfo(const MCAsmInfo &MAI);  // Real constructor.
 
170
  ~MachineModuleInfo();
 
171
  
 
172
  bool doInitialization();
 
173
  bool doFinalization();
 
174
 
 
175
  /// EndFunction - Discard function meta information.
 
176
  ///
 
177
  void EndFunction();
 
178
  
 
179
  const MCContext &getContext() const { return Context; }
 
180
  MCContext &getContext() { return Context; }
 
181
 
 
182
  void setModule(const Module *M) { TheModule = M; }
 
183
  const Module *getModule() const { return TheModule; }
 
184
  
 
185
  /// getInfo - Keep track of various per-function pieces of information for
 
186
  /// backends that would like to do so.
 
187
  ///
 
188
  template<typename Ty>
 
189
  Ty &getObjFileInfo() {
 
190
    if (ObjFileMMI == 0)
 
191
      ObjFileMMI = new Ty(*this);
 
192
    return *static_cast<Ty*>(ObjFileMMI);
 
193
  }
 
194
  
 
195
  template<typename Ty>
 
196
  const Ty &getObjFileInfo() const {
 
197
    return const_cast<MachineModuleInfo*>(this)->getObjFileInfo<Ty>();
 
198
  }
 
199
  
 
200
  /// AnalyzeModule - Scan the module for global debug information.
 
201
  ///
 
202
  void AnalyzeModule(const Module &M);
 
203
  
 
204
  /// hasDebugInfo - Returns true if valid debug info is present.
 
205
  ///
 
206
  bool hasDebugInfo() const { return DbgInfoAvailable; }
 
207
  void setDebugInfoAvailability(bool avail) { DbgInfoAvailable = true; }
 
208
 
 
209
  bool callsEHReturn() const { return CallsEHReturn; }
 
210
  void setCallsEHReturn(bool b) { CallsEHReturn = b; }
 
211
 
 
212
  bool callsUnwindInit() const { return CallsUnwindInit; }
 
213
  void setCallsUnwindInit(bool b) { CallsUnwindInit = b; }
 
214
  
 
215
  /// getFrameMoves - Returns a reference to a list of moves done in the current
 
216
  /// function's prologue.  Used to construct frame maps for debug and exception
 
217
  /// handling comsumers.
 
218
  std::vector<MachineMove> &getFrameMoves() { return FrameMoves; }
 
219
  
 
220
  /// getAddrLabelSymbol - Return the symbol to be used for the specified basic
 
221
  /// block when its address is taken.  This cannot be its normal LBB label
 
222
  /// because the block may be accessed outside its containing function.
 
223
  MCSymbol *getAddrLabelSymbol(const BasicBlock *BB);
 
224
 
 
225
  /// getAddrLabelSymbolToEmit - Return the symbol to be used for the specified
 
226
  /// basic block when its address is taken.  If other blocks were RAUW'd to
 
227
  /// this one, we may have to emit them as well, return the whole set.
 
228
  std::vector<MCSymbol*> getAddrLabelSymbolToEmit(const BasicBlock *BB);
 
229
  
 
230
  /// takeDeletedSymbolsForFunction - If the specified function has had any
 
231
  /// references to address-taken blocks generated, but the block got deleted,
 
232
  /// return the symbol now so we can emit it.  This prevents emitting a
 
233
  /// reference to a symbol that has no definition.
 
234
  void takeDeletedSymbolsForFunction(const Function *F, 
 
235
                                     std::vector<MCSymbol*> &Result);
 
236
 
 
237
  
 
238
  //===- EH ---------------------------------------------------------------===//
 
239
 
 
240
  /// getOrCreateLandingPadInfo - Find or create an LandingPadInfo for the
 
241
  /// specified MachineBasicBlock.
 
242
  LandingPadInfo &getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad);
 
243
 
 
244
  /// addInvoke - Provide the begin and end labels of an invoke style call and
 
245
  /// associate it with a try landing pad block.
 
246
  void addInvoke(MachineBasicBlock *LandingPad,
 
247
                 MCSymbol *BeginLabel, MCSymbol *EndLabel);
 
248
  
 
249
  /// addLandingPad - Add a new panding pad.  Returns the label ID for the 
 
250
  /// landing pad entry.
 
251
  MCSymbol *addLandingPad(MachineBasicBlock *LandingPad);
 
252
  
 
253
  /// addPersonality - Provide the personality function for the exception
 
254
  /// information.
 
255
  void addPersonality(MachineBasicBlock *LandingPad,
 
256
                      const Function *Personality);
 
257
 
 
258
  /// getPersonalityIndex - Get index of the current personality function inside
 
259
  /// Personalitites array
 
260
  unsigned getPersonalityIndex() const;
 
261
 
 
262
  /// getPersonalities - Return array of personality functions ever seen.
 
263
  const std::vector<const Function *>& getPersonalities() const {
 
264
    return Personalities;
 
265
  }
 
266
 
 
267
  /// isUsedFunction - Return true if the functions in the llvm.used list.  This
 
268
  /// does not return true for things in llvm.compiler.used unless they are also
 
269
  /// in llvm.used.
 
270
  bool isUsedFunction(const Function *F) {
 
271
    return UsedFunctions.count(F);
 
272
  }
 
273
 
 
274
  /// addCatchTypeInfo - Provide the catch typeinfo for a landing pad.
 
275
  ///
 
276
  void addCatchTypeInfo(MachineBasicBlock *LandingPad,
 
277
                        std::vector<const GlobalVariable *> &TyInfo);
 
278
 
 
279
  /// addFilterTypeInfo - Provide the filter typeinfo for a landing pad.
 
280
  ///
 
281
  void addFilterTypeInfo(MachineBasicBlock *LandingPad,
 
282
                         std::vector<const GlobalVariable *> &TyInfo);
 
283
 
 
284
  /// addCleanup - Add a cleanup action for a landing pad.
 
285
  ///
 
286
  void addCleanup(MachineBasicBlock *LandingPad);
 
287
 
 
288
  /// getTypeIDFor - Return the type id for the specified typeinfo.  This is 
 
289
  /// function wide.
 
290
  unsigned getTypeIDFor(const GlobalVariable *TI);
 
291
 
 
292
  /// getFilterIDFor - Return the id of the filter encoded by TyIds.  This is
 
293
  /// function wide.
 
294
  int getFilterIDFor(std::vector<unsigned> &TyIds);
 
295
 
 
296
  /// TidyLandingPads - Remap landing pad labels and remove any deleted landing
 
297
  /// pads.
 
298
  void TidyLandingPads(DenseMap<MCSymbol*, uintptr_t> *LPMap = 0);
 
299
                        
 
300
  /// getLandingPads - Return a reference to the landing pad info for the
 
301
  /// current function.
 
302
  const std::vector<LandingPadInfo> &getLandingPads() const {
 
303
    return LandingPads;
 
304
  }
 
305
 
 
306
  /// setCallSiteBeginLabel - Map the begin label for a call site
 
307
  void setCallSiteBeginLabel(MCSymbol *BeginLabel, unsigned Site) {
 
308
    CallSiteMap[BeginLabel] = Site;
 
309
  }
 
310
 
 
311
  /// getCallSiteBeginLabel - Get the call site number for a begin label
 
312
  unsigned getCallSiteBeginLabel(MCSymbol *BeginLabel) {
 
313
    assert(CallSiteMap.count(BeginLabel) &&
 
314
           "Missing call site number for EH_LABEL!");
 
315
    return CallSiteMap[BeginLabel];
 
316
  }
 
317
 
 
318
  /// setCurrentCallSite - Set the call site currently being processed.
 
319
  void setCurrentCallSite(unsigned Site) { CurCallSite = Site; }
 
320
 
 
321
  /// getCurrentCallSite - Get the call site currently being processed, if any.
 
322
  /// return zero if none.
 
323
  unsigned getCurrentCallSite(void) { return CurCallSite; }
 
324
 
 
325
  /// getTypeInfos - Return a reference to the C++ typeinfo for the current
 
326
  /// function.
 
327
  const std::vector<const GlobalVariable *> &getTypeInfos() const {
 
328
    return TypeInfos;
 
329
  }
 
330
 
 
331
  /// getFilterIds - Return a reference to the typeids encoding filters used in
 
332
  /// the current function.
 
333
  const std::vector<unsigned> &getFilterIds() const {
 
334
    return FilterIds;
 
335
  }
 
336
 
 
337
  /// getPersonality - Return a personality function if available.  The presence
 
338
  /// of one is required to emit exception handling info.
 
339
  const Function *getPersonality() const;
 
340
 
 
341
  /// setVariableDbgInfo - Collect information used to emit debugging
 
342
  /// information of a variable.
 
343
  void setVariableDbgInfo(MDNode *N, unsigned Slot, DebugLoc Loc) {
 
344
    VariableDbgInfo.push_back(std::make_pair(N, std::make_pair(Slot, Loc)));
 
345
  }
 
346
 
 
347
  VariableDbgInfoMapTy &getVariableDbgInfo() { return VariableDbgInfo; }
 
348
 
 
349
}; // End class MachineModuleInfo
 
350
 
 
351
} // End llvm namespace
 
352
 
 
353
#endif