← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/utils/TableGen/CodeGenInstruction.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/utils/TableGen/CodeGenInstruction.h
 
1
//===- CodeGenInstruction.h - Instruction Class Wrapper ---------*- 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 defines a wrapper class for the 'Instruction' TableGen class.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#ifndef CODEGEN_INSTRUCTION_H
 
15
#define CODEGEN_INSTRUCTION_H
 
16
 
 
17
#include "llvm/CodeGen/ValueTypes.h"
 
18
#include <string>
 
19
#include <vector>
 
20
#include <utility>
 
21
 
 
22
namespace llvm {
 
23
  class Record;
 
24
  class DagInit;
 
25
 
 
26
  class CodeGenInstruction {
 
27
  public:
 
28
    Record *TheDef;            // The actual record defining this instruction.
 
29
    std::string Namespace;     // The namespace the instruction is in.
 
30
 
 
31
    /// AsmString - The format string used to emit a .s file for the
 
32
    /// instruction.
 
33
    std::string AsmString;
 
34
    
 
35
    class ConstraintInfo {
 
36
      enum { None, EarlyClobber, Tied } Kind;
 
37
      unsigned OtherTiedOperand;
 
38
    public:
 
39
      ConstraintInfo() : Kind(None) {}
 
40
 
 
41
      static ConstraintInfo getEarlyClobber() {
 
42
        ConstraintInfo I;
 
43
        I.Kind = EarlyClobber;
 
44
        I.OtherTiedOperand = 0;
 
45
        return I;
 
46
      }
 
47
      
 
48
      static ConstraintInfo getTied(unsigned Op) {
 
49
        ConstraintInfo I;
 
50
        I.Kind = Tied;
 
51
        I.OtherTiedOperand = Op;
 
52
        return I;
 
53
      }
 
54
      
 
55
      bool isNone() const { return Kind == None; }
 
56
      bool isEarlyClobber() const { return Kind == EarlyClobber; }
 
57
      bool isTied() const { return Kind == Tied; }
 
58
      
 
59
      unsigned getTiedOperand() const {
 
60
        assert(isTied());
 
61
        return OtherTiedOperand;
 
62
      }
 
63
    };
 
64
    
 
65
    /// OperandInfo - The information we keep track of for each operand in the
 
66
    /// operand list for a tablegen instruction.
 
67
    struct OperandInfo {
 
68
      /// Rec - The definition this operand is declared as.
 
69
      ///
 
70
      Record *Rec;
 
71
 
 
72
      /// Name - If this operand was assigned a symbolic name, this is it,
 
73
      /// otherwise, it's empty.
 
74
      std::string Name;
 
75
 
 
76
      /// PrinterMethodName - The method used to print operands of this type in
 
77
      /// the asmprinter.
 
78
      std::string PrinterMethodName;
 
79
 
 
80
      /// MIOperandNo - Currently (this is meant to be phased out), some logical
 
81
      /// operands correspond to multiple MachineInstr operands.  In the X86
 
82
      /// target for example, one address operand is represented as 4
 
83
      /// MachineOperands.  Because of this, the operand number in the
 
84
      /// OperandList may not match the MachineInstr operand num.  Until it
 
85
      /// does, this contains the MI operand index of this operand.
 
86
      unsigned MIOperandNo;
 
87
      unsigned MINumOperands;   // The number of operands.
 
88
 
 
89
      /// DoNotEncode - Bools are set to true in this vector for each operand in
 
90
      /// the DisableEncoding list.  These should not be emitted by the code
 
91
      /// emitter.
 
92
      std::vector<bool> DoNotEncode;
 
93
      
 
94
      /// MIOperandInfo - Default MI operand type. Note an operand may be made
 
95
      /// up of multiple MI operands.
 
96
      DagInit *MIOperandInfo;
 
97
      
 
98
      /// Constraint info for this operand.  This operand can have pieces, so we
 
99
      /// track constraint info for each.
 
100
      std::vector<ConstraintInfo> Constraints;
 
101
 
 
102
      OperandInfo(Record *R, const std::string &N, const std::string &PMN, 
 
103
                  unsigned MION, unsigned MINO, DagInit *MIOI)
 
104
        : Rec(R), Name(N), PrinterMethodName(PMN), MIOperandNo(MION),
 
105
          MINumOperands(MINO), MIOperandInfo(MIOI) {}
 
106
    };
 
107
 
 
108
    /// NumDefs - Number of def operands declared.
 
109
    ///
 
110
    unsigned NumDefs;
 
111
 
 
112
    /// OperandList - The list of declared operands, along with their declared
 
113
    /// type (which is a record).
 
114
    std::vector<OperandInfo> OperandList;
 
115
 
 
116
    // Various boolean values we track for the instruction.
 
117
    bool isReturn;
 
118
    bool isBranch;
 
119
    bool isIndirectBranch;
 
120
    bool isBarrier;
 
121
    bool isCall;
 
122
    bool canFoldAsLoad;
 
123
    bool mayLoad, mayStore;
 
124
    bool isPredicable;
 
125
    bool isConvertibleToThreeAddress;
 
126
    bool isCommutable;
 
127
    bool isTerminator;
 
128
    bool isReMaterializable;
 
129
    bool hasDelaySlot;
 
130
    bool usesCustomInserter;
 
131
    bool isVariadic;
 
132
    bool hasCtrlDep;
 
133
    bool isNotDuplicable;
 
134
    bool hasOptionalDef;
 
135
    bool hasSideEffects;
 
136
    bool neverHasSideEffects;
 
137
    bool isAsCheapAsAMove;
 
138
    bool hasExtraSrcRegAllocReq;
 
139
    bool hasExtraDefRegAllocReq;
 
140
    
 
141
    /// ParseOperandName - Parse an operand name like "$foo" or "$foo.bar",
 
142
    /// where $foo is a whole operand and $foo.bar refers to a suboperand.
 
143
    /// This throws an exception if the name is invalid.  If AllowWholeOp is
 
144
    /// true, references to operands with suboperands are allowed, otherwise
 
145
    /// not.
 
146
    std::pair<unsigned,unsigned> ParseOperandName(const std::string &Op,
 
147
                                                  bool AllowWholeOp = true);
 
148
    
 
149
    /// getFlattenedOperandNumber - Flatten a operand/suboperand pair into a
 
150
    /// flat machineinstr operand #.
 
151
    unsigned getFlattenedOperandNumber(std::pair<unsigned,unsigned> Op) const {
 
152
      return OperandList[Op.first].MIOperandNo + Op.second;
 
153
    }
 
154
    
 
155
    /// getSubOperandNumber - Unflatten a operand number into an
 
156
    /// operand/suboperand pair.
 
157
    std::pair<unsigned,unsigned> getSubOperandNumber(unsigned Op) const {
 
158
      for (unsigned i = 0; ; ++i) {
 
159
        assert(i < OperandList.size() && "Invalid flat operand #");
 
160
        if (OperandList[i].MIOperandNo+OperandList[i].MINumOperands > Op)
 
161
          return std::make_pair(i, Op-OperandList[i].MIOperandNo);
 
162
      }
 
163
    }
 
164
    
 
165
    
 
166
    /// isFlatOperandNotEmitted - Return true if the specified flat operand #
 
167
    /// should not be emitted with the code emitter.
 
168
    bool isFlatOperandNotEmitted(unsigned FlatOpNo) const {
 
169
      std::pair<unsigned,unsigned> Op = getSubOperandNumber(FlatOpNo);
 
170
      if (OperandList[Op.first].DoNotEncode.size() > Op.second)
 
171
        return OperandList[Op.first].DoNotEncode[Op.second];
 
172
      return false;
 
173
    }
 
174
 
 
175
    CodeGenInstruction(Record *R, const std::string &AsmStr);
 
176
 
 
177
    /// getOperandNamed - Return the index of the operand with the specified
 
178
    /// non-empty name.  If the instruction does not have an operand with the
 
179
    /// specified name, throw an exception.
 
180
    unsigned getOperandNamed(const std::string &Name) const;
 
181
  };
 
182
}
 
183
 
 
184
#endif