← 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/TargetInstrItineraries.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/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
struct InstrStage {
 
51
  unsigned Cycles_;  ///< Length of stage in machine cycles
 
52
  unsigned Units_;   ///< Choice of functional units
 
53
  int NextCycles_;   ///< Number of machine cycles to next stage 
 
54
 
 
55
  /// getCycles - returns the number of cycles the stage is occupied
 
56
  unsigned getCycles() const {
 
57
    return Cycles_;
 
58
  }
 
59
 
 
60
  /// getUnits - returns the choice of FUs
 
61
  unsigned getUnits() const {
 
62
    return Units_;
 
63
  }
 
64
 
 
65
  /// getNextCycles - returns the number of cycles from the start of
 
66
  /// this stage to the start of the next stage in the itinerary
 
67
  unsigned getNextCycles() const {
 
68
    return (NextCycles_ >= 0) ? (unsigned)NextCycles_ : Cycles_;
 
69
  }
 
70
};
 
71
 
 
72
 
 
73
//===----------------------------------------------------------------------===//
 
74
/// Instruction itinerary - An itinerary represents the scheduling
 
75
/// information for an instruction. This includes a set of stages
 
76
/// occupies by the instruction, and the pipeline cycle in which
 
77
/// operands are read and written.
 
78
///
 
79
struct InstrItinerary {
 
80
  unsigned FirstStage;         ///< Index of first stage in itinerary
 
81
  unsigned LastStage;          ///< Index of last + 1 stage in itinerary
 
82
  unsigned FirstOperandCycle;  ///< Index of first operand rd/wr
 
83
  unsigned LastOperandCycle;   ///< Index of last + 1 operand rd/wr
 
84
};
 
85
 
 
86
 
 
87
//===----------------------------------------------------------------------===//
 
88
/// Instruction itinerary Data - Itinerary data supplied by a subtarget to be
 
89
/// used by a target.
 
90
///
 
91
struct InstrItineraryData {
 
92
  const InstrStage     *Stages;         ///< Array of stages selected
 
93
  const unsigned       *OperandCycles;  ///< Array of operand cycles selected
 
94
  const InstrItinerary *Itineratries;   ///< Array of itineraries selected
 
95
 
 
96
  /// Ctors.
 
97
  ///
 
98
  InstrItineraryData() : Stages(0), OperandCycles(0), Itineratries(0) {}
 
99
  InstrItineraryData(const InstrStage *S, const unsigned *OS,
 
100
                     const InstrItinerary *I)
 
101
    : Stages(S), OperandCycles(OS), Itineratries(I) {}
 
102
  
 
103
  /// isEmpty - Returns true if there are no itineraries.
 
104
  ///
 
105
  bool isEmpty() const { return Itineratries == 0; }
 
106
 
 
107
  /// isEndMarker - Returns true if the index is for the end marker
 
108
  /// itinerary.
 
109
  ///
 
110
  bool isEndMarker(unsigned ItinClassIndx) const {
 
111
    return ((Itineratries[ItinClassIndx].FirstStage == ~0U) &&
 
112
            (Itineratries[ItinClassIndx].LastStage == ~0U));
 
113
  }
 
114
 
 
115
  /// beginStage - Return the first stage of the itinerary.
 
116
  /// 
 
117
  const InstrStage *beginStage(unsigned ItinClassIndx) const {
 
118
    unsigned StageIdx = Itineratries[ItinClassIndx].FirstStage;
 
119
    return Stages + StageIdx;
 
120
  }
 
121
 
 
122
  /// endStage - Return the last+1 stage of the itinerary.
 
123
  /// 
 
124
  const InstrStage *endStage(unsigned ItinClassIndx) const {
 
125
    unsigned StageIdx = Itineratries[ItinClassIndx].LastStage;
 
126
    return Stages + StageIdx;
 
127
  }
 
128
 
 
129
  /// getStageLatency - Return the total stage latency of the given
 
130
  /// class.  The latency is the maximum completion time for any stage
 
131
  /// in the itinerary.
 
132
  ///
 
133
  unsigned getStageLatency(unsigned ItinClassIndx) const {
 
134
    // If the target doesn't provide itinerary information, use a
 
135
    // simple non-zero default value for all instructions.
 
136
    if (isEmpty())
 
137
      return 1;
 
138
 
 
139
    // Calculate the maximum completion time for any stage.
 
140
    unsigned Latency = 0, StartCycle = 0;
 
141
    for (const InstrStage *IS = beginStage(ItinClassIndx),
 
142
           *E = endStage(ItinClassIndx); IS != E; ++IS) {
 
143
      Latency = std::max(Latency, StartCycle + IS->getCycles());
 
144
      StartCycle += IS->getNextCycles();
 
145
    }
 
146
 
 
147
    return Latency;
 
148
  }
 
149
 
 
150
  /// getOperandCycle - Return the cycle for the given class and
 
151
  /// operand. Return -1 if no cycle is specified for the operand.
 
152
  ///
 
153
  int getOperandCycle(unsigned ItinClassIndx, unsigned OperandIdx) const {
 
154
    if (isEmpty())
 
155
      return -1;
 
156
 
 
157
    unsigned FirstIdx = Itineratries[ItinClassIndx].FirstOperandCycle;
 
158
    unsigned LastIdx = Itineratries[ItinClassIndx].LastOperandCycle;
 
159
    if ((FirstIdx + OperandIdx) >= LastIdx)
 
160
      return -1;
 
161
 
 
162
    return (int)OperandCycles[FirstIdx + OperandIdx];
 
163
  }
 
164
};
 
165
 
 
166
 
 
167
} // End llvm namespace
 
168
 
 
169
#endif