← Back to branch summary

~ubuntu-branches/ubuntu/wily/clamav/wily-proposed

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/Analysis/ConstantFolding.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/Analysis/ConstantFolding.h
 
1
//===-- ConstantFolding.h - Fold instructions into constants --------------===//
 
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 declares routines for folding instructions into constants.
 
11
//
 
12
// Also, to supplement the basic VMCore ConstantExpr simplifications,
 
13
// this file declares some additional folding routines that can make use of
 
14
// TargetData information. These functions cannot go in VMCore due to library
 
15
// dependency issues.
 
16
//
 
17
//===----------------------------------------------------------------------===//
 
18
 
 
19
#ifndef LLVM_ANALYSIS_CONSTANTFOLDING_H
 
20
#define LLVM_ANALYSIS_CONSTANTFOLDING_H
 
21
 
 
22
namespace llvm {
 
23
  class Constant;
 
24
  class ConstantExpr;
 
25
  class Instruction;
 
26
  class TargetData;
 
27
  class Function;
 
28
  class Type;
 
29
 
 
30
/// ConstantFoldInstruction - Attempt to constant fold the specified
 
31
/// instruction.  If successful, the constant result is returned, if not, null
 
32
/// is returned.  Note that this function can only fail when attempting to fold
 
33
/// instructions like loads and stores, which have no constant expression form.
 
34
///
 
35
Constant *ConstantFoldInstruction(Instruction *I, const TargetData *TD = 0);
 
36
 
 
37
/// ConstantFoldConstantExpression - Attempt to fold the constant expression
 
38
/// using the specified TargetData.  If successful, the constant result is
 
39
/// result is returned, if not, null is returned.
 
40
Constant *ConstantFoldConstantExpression(const ConstantExpr *CE,
 
41
                                         const TargetData *TD = 0);
 
42
 
 
43
/// ConstantFoldInstOperands - Attempt to constant fold an instruction with the
 
44
/// specified operands.  If successful, the constant result is returned, if not,
 
45
/// null is returned.  Note that this function can fail when attempting to 
 
46
/// fold instructions like loads and stores, which have no constant expression 
 
47
/// form.
 
48
///
 
49
Constant *ConstantFoldInstOperands(unsigned Opcode, const Type *DestTy,
 
50
                                   Constant *const *Ops, unsigned NumOps,
 
51
                                   const TargetData *TD = 0);
 
52
 
 
53
/// ConstantFoldCompareInstOperands - Attempt to constant fold a compare
 
54
/// instruction (icmp/fcmp) with the specified operands.  If it fails, it
 
55
/// returns a constant expression of the specified operands.
 
56
///
 
57
Constant *ConstantFoldCompareInstOperands(unsigned Predicate,
 
58
                                          Constant *LHS, Constant *RHS,
 
59
                                          const TargetData *TD = 0);
 
60
 
 
61
/// ConstantFoldLoadFromConstPtr - Return the value that a load from C would
 
62
/// produce if it is constant and determinable.  If this is not determinable,
 
63
/// return null.
 
64
Constant *ConstantFoldLoadFromConstPtr(Constant *C, const TargetData *TD = 0);
 
65
 
 
66
/// ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a
 
67
/// getelementptr constantexpr, return the constant value being addressed by the
 
68
/// constant expression, or null if something is funny and we can't decide.
 
69
Constant *ConstantFoldLoadThroughGEPConstantExpr(Constant *C, ConstantExpr *CE);
 
70
  
 
71
/// canConstantFoldCallTo - Return true if its even possible to fold a call to
 
72
/// the specified function.
 
73
bool canConstantFoldCallTo(const Function *F);
 
74
 
 
75
/// ConstantFoldCall - Attempt to constant fold a call to the specified function
 
76
/// with the specified arguments, returning null if unsuccessful.
 
77
Constant *
 
78
ConstantFoldCall(Function *F, Constant *const *Operands, unsigned NumOperands);
 
79
}
 
80
 
 
81
#endif