← 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/Target/TargetInstrItineraries.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/Target/TargetInstrItineraries.h
 
1
//===-- llvm/Target/TargetInstrItineraries.h - Scheduling -------*- 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 describes the structures used for instruction
 
11
// itineraries, stages, and operand reads/writes.  This is used by
 
12
// schedulers to determine instruction stages and latencies.
 
13
//
 
14
//===----------------------------------------------------------------------===//
 
15
 
 
16
#ifndef LLVM_TARGET_TARGETINSTRITINERARIES_H
 
17
#define LLVM_TARGET_TARGETINSTRITINERARIES_H
 
18
 
 
19
#include <algorithm>
 
20
 
 
21
namespace llvm {
 
22
 
 
23
//===----------------------------------------------------------------------===//
 
24
/// Instruction stage - These values represent a non-pipelined step in
 
25
/// the execution of an instruction.  Cycles represents the number of
 
26
/// discrete time slots needed to complete the stage.  Units represent
 
27
/// the choice of functional units that can be used to complete the
 
28
/// stage.  Eg. IntUnit1, IntUnit2. NextCycles indicates how many
 
29
/// cycles should elapse from the start of this stage to the start of
 
30
/// the next stage in the itinerary. A value of -1 indicates that the
 
31
/// next stage should start immediately after the current one.
 
32
/// For example:
 
33
///
 
34
///   { 1, x, -1 }
 
35
///      indicates that the stage occupies FU x for 1 cycle and that
 
36
///      the next stage starts immediately after this one.
 
37
///
 
38
///   { 2, x|y, 1 }
 
39
///      indicates that the stage occupies either FU x or FU y for 2
 
40
///      consecuative cycles and that the next stage starts one cycle
 
41
///      after this stage starts. That is, the stage requirements
 
42
///      overlap in time.
 
43
///
 
44
///   { 1, x, 0 }
 
45
///      indicates that the stage occupies FU x for 1 cycle and that
 
46
///      the next stage starts in this same cycle. This can be used to
 
47
///      indicate that the instruction requires multiple stages at the
 
48
///      same time.
 
49
///
 
50
/// FU reservation can be of two different kinds:
 
51
///  - FUs which instruction actually requires
 
52
///  - FUs which instruction just reserves. Reserved unit is not available for
 
53
///    execution of other instruction. However, several instructions can reserve
 
54
///    the same unit several times.
 
55
/// Such two types of units reservation is used to model instruction domain
 
56
/// change stalls, FUs using the same resource (e.g. same register file), etc.
 
57
 
 
58
struct InstrStage {
 
59
  enum ReservationKinds {
 
60
    Required = 0,
 
61
    Reserved = 1
 
62
  };
 
63
 
 
64
  unsigned Cycles_;  ///< Length of stage in machine cycles
 
65
  unsigned Units_;   ///< Choice of functional units
 
66
  int NextCycles_;   ///< Number of machine cycles to next stage
 
67
  ReservationKinds Kind_; ///< Kind of the FU reservation
 
68
 
 
69
  /// getCycles - returns the number of cycles the stage is occupied
 
70
  unsigned getCycles() const {
 
71
    return Cycles_;
 
72
  }
 
73
 
 
74
  /// getUnits - returns the choice of FUs
 
75
  unsigned getUnits() const {
 
76
    return Units_;
 
77
  }
 
78
 
 
79
  ReservationKinds getReservationKind() const {
 
80
    return Kind_;
 
81
  }
 
82
 
 
83
  /// getNextCycles - returns the number of cycles from the start of
 
84
  /// this stage to the start of the next stage in the itinerary
 
85
  unsigned getNextCycles() const {
 
86
    return (NextCycles_ >= 0) ? (unsigned)NextCycles_ : Cycles_;
 
87
  }
 
88
};
 
89
 
 
90
 
 
91
//===----------------------------------------------------------------------===//
 
92
/// Instruction itinerary - An itinerary represents the scheduling
 
93
/// information for an instruction. This includes a set of stages
 
94
/// occupies by the instruction, and the pipeline cycle in which
 
95
/// operands are read and written.
 
96
///
 
97
struct InstrItinerary {
 
98
  unsigned FirstStage;         ///< Index of first stage in itinerary
 
99
  unsigned LastStage;          ///< Index of last + 1 stage in itinerary
 
100
  unsigned FirstOperandCycle;  ///< Index of first operand rd/wr
 
101
  unsigned LastOperandCycle;   ///< Index of last + 1 operand rd/wr
 
102
};
 
103
 
 
104
 
 
105
//===----------------------------------------------------------------------===//
 
106
/// Instruction itinerary Data - Itinerary data supplied by a subtarget to be
 
107
/// used by a target.
 
108
///
 
109
class InstrItineraryData {
 
110
public:
 
111
  const InstrStage     *Stages;         ///< Array of stages selected
 
112
  const unsigned       *OperandCycles;  ///< Array of operand cycles selected
 
113
  const InstrItinerary *Itineratries;   ///< Array of itineraries selected
 
114
 
 
115
  /// Ctors.
 
116
  ///
 
117
  InstrItineraryData() : Stages(0), OperandCycles(0), Itineratries(0) {}
 
118
  InstrItineraryData(const InstrStage *S, const unsigned *OS,
 
119
                     const InstrItinerary *I)
 
120
    : Stages(S), OperandCycles(OS), Itineratries(I) {}
 
121
  
 
122
  /// isEmpty - Returns true if there are no itineraries.
 
123
  ///
 
124
  bool isEmpty() const { return Itineratries == 0; }
 
125
 
 
126
  /// isEndMarker - Returns true if the index is for the end marker
 
127
  /// itinerary.
 
128
  ///
 
129
  bool isEndMarker(unsigned ItinClassIndx) const {
 
130
    return ((Itineratries[ItinClassIndx].FirstStage == ~0U) &&
 
131
            (Itineratries[ItinClassIndx].LastStage == ~0U));
 
132
  }
 
133
 
 
134
  /// beginStage - Return the first stage of the itinerary.
 
135
  /// 
 
136
  const InstrStage *beginStage(unsigned ItinClassIndx) const {
 
137
    unsigned StageIdx = Itineratries[ItinClassIndx].FirstStage;
 
138
    return Stages + StageIdx;
 
139
  }
 
140
 
 
141
  /// endStage - Return the last+1 stage of the itinerary.
 
142
  /// 
 
143
  const InstrStage *endStage(unsigned ItinClassIndx) const {
 
144
    unsigned StageIdx = Itineratries[ItinClassIndx].LastStage;
 
145
    return Stages + StageIdx;
 
146
  }
 
147
 
 
148
  /// getStageLatency - Return the total stage latency of the given
 
149
  /// class.  The latency is the maximum completion time for any stage
 
150
  /// in the itinerary.
 
151
  ///
 
152
  unsigned getStageLatency(unsigned ItinClassIndx) const {
 
153
    // If the target doesn't provide itinerary information, use a
 
154
    // simple non-zero default value for all instructions.
 
155
    if (isEmpty())
 
156
      return 1;
 
157
 
 
158
    // Calculate the maximum completion time for any stage.
 
159
    unsigned Latency = 0, StartCycle = 0;
 
160
    for (const InstrStage *IS = beginStage(ItinClassIndx),
 
161
           *E = endStage(ItinClassIndx); IS != E; ++IS) {
 
162
      Latency = std::max(Latency, StartCycle + IS->getCycles());
 
163
      StartCycle += IS->getNextCycles();
 
164
    }
 
165
 
 
166
    return Latency;
 
167
  }
 
168
 
 
169
  /// getOperandCycle - Return the cycle for the given class and
 
170
  /// operand. Return -1 if no cycle is specified for the operand.
 
171
  ///
 
172
  int getOperandCycle(unsigned ItinClassIndx, unsigned OperandIdx) const {
 
173
    if (isEmpty())
 
174
      return -1;
 
175
 
 
176
    unsigned FirstIdx = Itineratries[ItinClassIndx].FirstOperandCycle;
 
177
    unsigned LastIdx = Itineratries[ItinClassIndx].LastOperandCycle;
 
178
    if ((FirstIdx + OperandIdx) >= LastIdx)
 
179
      return -1;
 
180
 
 
181
    return (int)OperandCycles[FirstIdx + OperandIdx];
 
182
  }
 
183
};
 
184
 
 
185
 
 
186
} // End llvm namespace
 
187
 
 
188
#endif