← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/Target/ARM/NEONPreAllocPass.cpp

  • 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/lib/Target/ARM/NEONPreAllocPass.cpp
 
1
//===-- NEONPreAllocPass.cpp - Allocate adjacent NEON registers--*- 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
#define DEBUG_TYPE "neon-prealloc"
 
11
#include "ARM.h"
 
12
#include "ARMInstrInfo.h"
 
13
#include "llvm/CodeGen/MachineInstr.h"
 
14
#include "llvm/CodeGen/MachineInstrBuilder.h"
 
15
#include "llvm/CodeGen/MachineFunctionPass.h"
 
16
using namespace llvm;
 
17
 
 
18
namespace {
 
19
  class NEONPreAllocPass : public MachineFunctionPass {
 
20
    const TargetInstrInfo *TII;
 
21
 
 
22
  public:
 
23
    static char ID;
 
24
    NEONPreAllocPass() : MachineFunctionPass(&ID) {}
 
25
 
 
26
    virtual bool runOnMachineFunction(MachineFunction &MF);
 
27
 
 
28
    virtual const char *getPassName() const {
 
29
      return "NEON register pre-allocation pass";
 
30
    }
 
31
 
 
32
  private:
 
33
    bool PreAllocNEONRegisters(MachineBasicBlock &MBB);
 
34
  };
 
35
 
 
36
  char NEONPreAllocPass::ID = 0;
 
37
}
 
38
 
 
39
static bool isNEONMultiRegOp(int Opcode, unsigned &FirstOpnd, unsigned &NumRegs,
 
40
                             unsigned &Offset, unsigned &Stride) {
 
41
  // Default to unit stride with no offset.
 
42
  Stride = 1;
 
43
  Offset = 0;
 
44
 
 
45
  switch (Opcode) {
 
46
  default:
 
47
    break;
 
48
 
 
49
  case ARM::VLD2d8:
 
50
  case ARM::VLD2d16:
 
51
  case ARM::VLD2d32:
 
52
  case ARM::VLD2d64:
 
53
  case ARM::VLD2LNd8:
 
54
  case ARM::VLD2LNd16:
 
55
  case ARM::VLD2LNd32:
 
56
    FirstOpnd = 0;
 
57
    NumRegs = 2;
 
58
    return true;
 
59
 
 
60
  case ARM::VLD2q8:
 
61
  case ARM::VLD2q16:
 
62
  case ARM::VLD2q32:
 
63
    FirstOpnd = 0;
 
64
    NumRegs = 4;
 
65
    return true;
 
66
 
 
67
  case ARM::VLD2LNq16a:
 
68
  case ARM::VLD2LNq32a:
 
69
    FirstOpnd = 0;
 
70
    NumRegs = 2;
 
71
    Offset = 0;
 
72
    Stride = 2;
 
73
    return true;
 
74
 
 
75
  case ARM::VLD2LNq16b:
 
76
  case ARM::VLD2LNq32b:
 
77
    FirstOpnd = 0;
 
78
    NumRegs = 2;
 
79
    Offset = 1;
 
80
    Stride = 2;
 
81
    return true;
 
82
 
 
83
  case ARM::VLD3d8:
 
84
  case ARM::VLD3d16:
 
85
  case ARM::VLD3d32:
 
86
  case ARM::VLD3d64:
 
87
  case ARM::VLD3LNd8:
 
88
  case ARM::VLD3LNd16:
 
89
  case ARM::VLD3LNd32:
 
90
    FirstOpnd = 0;
 
91
    NumRegs = 3;
 
92
    return true;
 
93
 
 
94
  case ARM::VLD3q8a:
 
95
  case ARM::VLD3q16a:
 
96
  case ARM::VLD3q32a:
 
97
    FirstOpnd = 0;
 
98
    NumRegs = 3;
 
99
    Offset = 0;
 
100
    Stride = 2;
 
101
    return true;
 
102
 
 
103
  case ARM::VLD3q8b:
 
104
  case ARM::VLD3q16b:
 
105
  case ARM::VLD3q32b:
 
106
    FirstOpnd = 0;
 
107
    NumRegs = 3;
 
108
    Offset = 1;
 
109
    Stride = 2;
 
110
    return true;
 
111
 
 
112
  case ARM::VLD3LNq16a:
 
113
  case ARM::VLD3LNq32a:
 
114
    FirstOpnd = 0;
 
115
    NumRegs = 3;
 
116
    Offset = 0;
 
117
    Stride = 2;
 
118
    return true;
 
119
 
 
120
  case ARM::VLD3LNq16b:
 
121
  case ARM::VLD3LNq32b:
 
122
    FirstOpnd = 0;
 
123
    NumRegs = 3;
 
124
    Offset = 1;
 
125
    Stride = 2;
 
126
    return true;
 
127
 
 
128
  case ARM::VLD4d8:
 
129
  case ARM::VLD4d16:
 
130
  case ARM::VLD4d32:
 
131
  case ARM::VLD4d64:
 
132
  case ARM::VLD4LNd8:
 
133
  case ARM::VLD4LNd16:
 
134
  case ARM::VLD4LNd32:
 
135
    FirstOpnd = 0;
 
136
    NumRegs = 4;
 
137
    return true;
 
138
 
 
139
  case ARM::VLD4q8a:
 
140
  case ARM::VLD4q16a:
 
141
  case ARM::VLD4q32a:
 
142
    FirstOpnd = 0;
 
143
    NumRegs = 4;
 
144
    Offset = 0;
 
145
    Stride = 2;
 
146
    return true;
 
147
 
 
148
  case ARM::VLD4q8b:
 
149
  case ARM::VLD4q16b:
 
150
  case ARM::VLD4q32b:
 
151
    FirstOpnd = 0;
 
152
    NumRegs = 4;
 
153
    Offset = 1;
 
154
    Stride = 2;
 
155
    return true;
 
156
 
 
157
  case ARM::VLD4LNq16a:
 
158
  case ARM::VLD4LNq32a:
 
159
    FirstOpnd = 0;
 
160
    NumRegs = 4;
 
161
    Offset = 0;
 
162
    Stride = 2;
 
163
    return true;
 
164
 
 
165
  case ARM::VLD4LNq16b:
 
166
  case ARM::VLD4LNq32b:
 
167
    FirstOpnd = 0;
 
168
    NumRegs = 4;
 
169
    Offset = 1;
 
170
    Stride = 2;
 
171
    return true;
 
172
 
 
173
  case ARM::VST2d8:
 
174
  case ARM::VST2d16:
 
175
  case ARM::VST2d32:
 
176
  case ARM::VST2d64:
 
177
  case ARM::VST2LNd8:
 
178
  case ARM::VST2LNd16:
 
179
  case ARM::VST2LNd32:
 
180
    FirstOpnd = 4;
 
181
    NumRegs = 2;
 
182
    return true;
 
183
 
 
184
  case ARM::VST2q8:
 
185
  case ARM::VST2q16:
 
186
  case ARM::VST2q32:
 
187
    FirstOpnd = 4;
 
188
    NumRegs = 4;
 
189
    return true;
 
190
 
 
191
  case ARM::VST2LNq16a:
 
192
  case ARM::VST2LNq32a:
 
193
    FirstOpnd = 4;
 
194
    NumRegs = 2;
 
195
    Offset = 0;
 
196
    Stride = 2;
 
197
    return true;
 
198
 
 
199
  case ARM::VST2LNq16b:
 
200
  case ARM::VST2LNq32b:
 
201
    FirstOpnd = 4;
 
202
    NumRegs = 2;
 
203
    Offset = 1;
 
204
    Stride = 2;
 
205
    return true;
 
206
 
 
207
  case ARM::VST3d8:
 
208
  case ARM::VST3d16:
 
209
  case ARM::VST3d32:
 
210
  case ARM::VST3d64:
 
211
  case ARM::VST3LNd8:
 
212
  case ARM::VST3LNd16:
 
213
  case ARM::VST3LNd32:
 
214
    FirstOpnd = 4;
 
215
    NumRegs = 3;
 
216
    return true;
 
217
 
 
218
  case ARM::VST3q8a:
 
219
  case ARM::VST3q16a:
 
220
  case ARM::VST3q32a:
 
221
    FirstOpnd = 5;
 
222
    NumRegs = 3;
 
223
    Offset = 0;
 
224
    Stride = 2;
 
225
    return true;
 
226
 
 
227
  case ARM::VST3q8b:
 
228
  case ARM::VST3q16b:
 
229
  case ARM::VST3q32b:
 
230
    FirstOpnd = 5;
 
231
    NumRegs = 3;
 
232
    Offset = 1;
 
233
    Stride = 2;
 
234
    return true;
 
235
 
 
236
  case ARM::VST3LNq16a:
 
237
  case ARM::VST3LNq32a:
 
238
    FirstOpnd = 4;
 
239
    NumRegs = 3;
 
240
    Offset = 0;
 
241
    Stride = 2;
 
242
    return true;
 
243
 
 
244
  case ARM::VST3LNq16b:
 
245
  case ARM::VST3LNq32b:
 
246
    FirstOpnd = 4;
 
247
    NumRegs = 3;
 
248
    Offset = 1;
 
249
    Stride = 2;
 
250
    return true;
 
251
 
 
252
  case ARM::VST4d8:
 
253
  case ARM::VST4d16:
 
254
  case ARM::VST4d32:
 
255
  case ARM::VST4d64:
 
256
  case ARM::VST4LNd8:
 
257
  case ARM::VST4LNd16:
 
258
  case ARM::VST4LNd32:
 
259
    FirstOpnd = 4;
 
260
    NumRegs = 4;
 
261
    return true;
 
262
 
 
263
  case ARM::VST4q8a:
 
264
  case ARM::VST4q16a:
 
265
  case ARM::VST4q32a:
 
266
    FirstOpnd = 5;
 
267
    NumRegs = 4;
 
268
    Offset = 0;
 
269
    Stride = 2;
 
270
    return true;
 
271
 
 
272
  case ARM::VST4q8b:
 
273
  case ARM::VST4q16b:
 
274
  case ARM::VST4q32b:
 
275
    FirstOpnd = 5;
 
276
    NumRegs = 4;
 
277
    Offset = 1;
 
278
    Stride = 2;
 
279
    return true;
 
280
 
 
281
  case ARM::VST4LNq16a:
 
282
  case ARM::VST4LNq32a:
 
283
    FirstOpnd = 4;
 
284
    NumRegs = 4;
 
285
    Offset = 0;
 
286
    Stride = 2;
 
287
    return true;
 
288
 
 
289
  case ARM::VST4LNq16b:
 
290
  case ARM::VST4LNq32b:
 
291
    FirstOpnd = 4;
 
292
    NumRegs = 4;
 
293
    Offset = 1;
 
294
    Stride = 2;
 
295
    return true;
 
296
 
 
297
  case ARM::VTBL2:
 
298
    FirstOpnd = 1;
 
299
    NumRegs = 2;
 
300
    return true;
 
301
 
 
302
  case ARM::VTBL3:
 
303
    FirstOpnd = 1;
 
304
    NumRegs = 3;
 
305
    return true;
 
306
 
 
307
  case ARM::VTBL4:
 
308
    FirstOpnd = 1;
 
309
    NumRegs = 4;
 
310
    return true;
 
311
 
 
312
  case ARM::VTBX2:
 
313
    FirstOpnd = 2;
 
314
    NumRegs = 2;
 
315
    return true;
 
316
 
 
317
  case ARM::VTBX3:
 
318
    FirstOpnd = 2;
 
319
    NumRegs = 3;
 
320
    return true;
 
321
 
 
322
  case ARM::VTBX4:
 
323
    FirstOpnd = 2;
 
324
    NumRegs = 4;
 
325
    return true;
 
326
  }
 
327
 
 
328
  return false;
 
329
}
 
330
 
 
331
bool NEONPreAllocPass::PreAllocNEONRegisters(MachineBasicBlock &MBB) {
 
332
  bool Modified = false;
 
333
 
 
334
  MachineBasicBlock::iterator MBBI = MBB.begin(), E = MBB.end();
 
335
  for (; MBBI != E; ++MBBI) {
 
336
    MachineInstr *MI = &*MBBI;
 
337
    unsigned FirstOpnd, NumRegs, Offset, Stride;
 
338
    if (!isNEONMultiRegOp(MI->getOpcode(), FirstOpnd, NumRegs, Offset, Stride))
 
339
      continue;
 
340
 
 
341
    MachineBasicBlock::iterator NextI = llvm::next(MBBI);
 
342
    for (unsigned R = 0; R < NumRegs; ++R) {
 
343
      MachineOperand &MO = MI->getOperand(FirstOpnd + R);
 
344
      assert(MO.isReg() && MO.getSubReg() == 0 && "unexpected operand");
 
345
      unsigned VirtReg = MO.getReg();
 
346
      assert(TargetRegisterInfo::isVirtualRegister(VirtReg) &&
 
347
             "expected a virtual register");
 
348
 
 
349
      // For now, just assign a fixed set of adjacent registers.
 
350
      // This leaves plenty of room for future improvements.
 
351
      static const unsigned NEONDRegs[] = {
 
352
        ARM::D0, ARM::D1, ARM::D2, ARM::D3,
 
353
        ARM::D4, ARM::D5, ARM::D6, ARM::D7
 
354
      };
 
355
      MO.setReg(NEONDRegs[Offset + R * Stride]);
 
356
 
 
357
      if (MO.isUse()) {
 
358
        // Insert a copy from VirtReg.
 
359
        TII->copyRegToReg(MBB, MBBI, MO.getReg(), VirtReg,
 
360
                          ARM::DPRRegisterClass, ARM::DPRRegisterClass);
 
361
        if (MO.isKill()) {
 
362
          MachineInstr *CopyMI = prior(MBBI);
 
363
          CopyMI->findRegisterUseOperand(VirtReg)->setIsKill();
 
364
        }
 
365
        MO.setIsKill();
 
366
      } else if (MO.isDef() && !MO.isDead()) {
 
367
        // Add a copy to VirtReg.
 
368
        TII->copyRegToReg(MBB, NextI, VirtReg, MO.getReg(),
 
369
                          ARM::DPRRegisterClass, ARM::DPRRegisterClass);
 
370
      }
 
371
    }
 
372
  }
 
373
 
 
374
  return Modified;
 
375
}
 
376
 
 
377
bool NEONPreAllocPass::runOnMachineFunction(MachineFunction &MF) {
 
378
  TII = MF.getTarget().getInstrInfo();
 
379
 
 
380
  bool Modified = false;
 
381
  for (MachineFunction::iterator MFI = MF.begin(), E = MF.end(); MFI != E;
 
382
       ++MFI) {
 
383
    MachineBasicBlock &MBB = *MFI;
 
384
    Modified |= PreAllocNEONRegisters(MBB);
 
385
  }
 
386
 
 
387
  return Modified;
 
388
}
 
389
 
 
390
/// createNEONPreAllocPass - returns an instance of the NEON register
 
391
/// pre-allocation pass.
 
392
FunctionPass *llvm::createNEONPreAllocPass() {
 
393
  return new NEONPreAllocPass();
 
394
}