← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/X86GenCallingConv.inc

  • 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++/X86GenCallingConv.inc
 
1
//===- TableGen'erated file -------------------------------------*- C++ -*-===//
 
2
//
 
3
// Calling Convention Implementation Fragment
 
4
//
 
5
// Automatically generated file, do not edit!
 
6
//
 
7
//===----------------------------------------------------------------------===//
 
8
 
 
9
static bool CC_X86_32_C(unsigned ValNo, EVT ValVT,
 
10
                        EVT LocVT, CCValAssign::LocInfo LocInfo,
 
11
                        ISD::ArgFlagsTy ArgFlags, CCState &State);
 
12
static bool CC_X86_32_Common(unsigned ValNo, EVT ValVT,
 
13
                             EVT LocVT, CCValAssign::LocInfo LocInfo,
 
14
                             ISD::ArgFlagsTy ArgFlags, CCState &State);
 
15
static bool CC_X86_32_FastCC(unsigned ValNo, EVT ValVT,
 
16
                             EVT LocVT, CCValAssign::LocInfo LocInfo,
 
17
                             ISD::ArgFlagsTy ArgFlags, CCState &State);
 
18
static bool CC_X86_32_FastCall(unsigned ValNo, EVT ValVT,
 
19
                               EVT LocVT, CCValAssign::LocInfo LocInfo,
 
20
                               ISD::ArgFlagsTy ArgFlags, CCState &State);
 
21
static bool CC_X86_64_C(unsigned ValNo, EVT ValVT,
 
22
                        EVT LocVT, CCValAssign::LocInfo LocInfo,
 
23
                        ISD::ArgFlagsTy ArgFlags, CCState &State);
 
24
static bool CC_X86_Win64_C(unsigned ValNo, EVT ValVT,
 
25
                           EVT LocVT, CCValAssign::LocInfo LocInfo,
 
26
                           ISD::ArgFlagsTy ArgFlags, CCState &State);
 
27
static bool RetCC_X86(unsigned ValNo, EVT ValVT,
 
28
                      EVT LocVT, CCValAssign::LocInfo LocInfo,
 
29
                      ISD::ArgFlagsTy ArgFlags, CCState &State);
 
30
static bool RetCC_X86Common(unsigned ValNo, EVT ValVT,
 
31
                            EVT LocVT, CCValAssign::LocInfo LocInfo,
 
32
                            ISD::ArgFlagsTy ArgFlags, CCState &State);
 
33
static bool RetCC_X86_32(unsigned ValNo, EVT ValVT,
 
34
                         EVT LocVT, CCValAssign::LocInfo LocInfo,
 
35
                         ISD::ArgFlagsTy ArgFlags, CCState &State);
 
36
static bool RetCC_X86_32_C(unsigned ValNo, EVT ValVT,
 
37
                           EVT LocVT, CCValAssign::LocInfo LocInfo,
 
38
                           ISD::ArgFlagsTy ArgFlags, CCState &State);
 
39
static bool RetCC_X86_32_Fast(unsigned ValNo, EVT ValVT,
 
40
                              EVT LocVT, CCValAssign::LocInfo LocInfo,
 
41
                              ISD::ArgFlagsTy ArgFlags, CCState &State);
 
42
static bool RetCC_X86_64(unsigned ValNo, EVT ValVT,
 
43
                         EVT LocVT, CCValAssign::LocInfo LocInfo,
 
44
                         ISD::ArgFlagsTy ArgFlags, CCState &State);
 
45
static bool RetCC_X86_64_C(unsigned ValNo, EVT ValVT,
 
46
                           EVT LocVT, CCValAssign::LocInfo LocInfo,
 
47
                           ISD::ArgFlagsTy ArgFlags, CCState &State);
 
48
static bool RetCC_X86_Win64_C(unsigned ValNo, EVT ValVT,
 
49
                              EVT LocVT, CCValAssign::LocInfo LocInfo,
 
50
                              ISD::ArgFlagsTy ArgFlags, CCState &State);
 
51
 
 
52
 
 
53
static bool CC_X86_32_C(unsigned ValNo, EVT ValVT,
 
54
                        EVT LocVT, CCValAssign::LocInfo LocInfo,
 
55
                        ISD::ArgFlagsTy ArgFlags, CCState &State) {
 
56
 
 
57
  if (LocVT == MVT::i8 ||
 
58
      LocVT == MVT::i16) {
 
59
    LocVT = MVT::i32;
 
60
    if (ArgFlags.isSExt())
 
61
        LocInfo = CCValAssign::SExt;
 
62
    else if (ArgFlags.isZExt())
 
63
        LocInfo = CCValAssign::ZExt;
 
64
    else
 
65
        LocInfo = CCValAssign::AExt;
 
66
  }
 
67
 
 
68
  if (ArgFlags.isNest()) {
 
69
    if (unsigned Reg = State.AllocateReg(X86::ECX)) {
 
70
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
71
      return false;
 
72
    }
 
73
  }
 
74
 
 
75
  if (!State.isVarArg()) {
 
76
    if (ArgFlags.isInReg()) {
 
77
      if (LocVT == MVT::i32) {
 
78
        static const unsigned RegList1[] = {
 
79
          X86::EAX, X86::EDX, X86::ECX
 
80
        };
 
81
        if (unsigned Reg = State.AllocateReg(RegList1, 3)) {
 
82
          State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
83
          return false;
 
84
        }
 
85
      }
 
86
    }
 
87
  }
 
88
 
 
89
  if (!CC_X86_32_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
 
90
    return false;
 
91
 
 
92
  return true;  // CC didn't match.
 
93
}
 
94
 
 
95
 
 
96
static bool CC_X86_32_Common(unsigned ValNo, EVT ValVT,
 
97
                             EVT LocVT, CCValAssign::LocInfo LocInfo,
 
98
                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
 
99
 
 
100
  if (ArgFlags.isByVal()) {
 
101
    State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
 
102
    return false;
 
103
  }
 
104
 
 
105
  if (!State.isVarArg()) {
 
106
    if (ArgFlags.isInReg()) {
 
107
      if (LocVT == MVT::f32 ||
 
108
          LocVT == MVT::f64) {
 
109
        if (State.getTarget().getSubtarget<X86Subtarget>().hasSSE2()) {
 
110
          static const unsigned RegList1[] = {
 
111
            X86::XMM0, X86::XMM1, X86::XMM2
 
112
          };
 
113
          if (unsigned Reg = State.AllocateReg(RegList1, 3)) {
 
114
            State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
115
            return false;
 
116
          }
 
117
        }
 
118
      }
 
119
    }
 
120
  }
 
121
 
 
122
  if (!State.isVarArg()) {
 
123
    if (LocVT == MVT::v8i8 ||
 
124
        LocVT == MVT::v4i16 ||
 
125
        LocVT == MVT::v2i32 ||
 
126
        LocVT == MVT::v2f32) {
 
127
      static const unsigned RegList2[] = {
 
128
        X86::MM0, X86::MM1, X86::MM2
 
129
      };
 
130
      if (unsigned Reg = State.AllocateReg(RegList2, 3)) {
 
131
        State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
132
        return false;
 
133
      }
 
134
    }
 
135
  }
 
136
 
 
137
  if (LocVT == MVT::i32 ||
 
138
      LocVT == MVT::f32) {
 
139
    unsigned Offset3 = State.AllocateStack(4, 4);
 
140
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo));
 
141
    return false;
 
142
  }
 
143
 
 
144
  if (LocVT == MVT::f64) {
 
145
    unsigned Offset4 = State.AllocateStack(8, 4);
 
146
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo));
 
147
    return false;
 
148
  }
 
149
 
 
150
  if (LocVT == MVT::f80) {
 
151
    unsigned Offset5 = State.AllocateStack(
 
152
      State.getTarget().getTargetData()->getTypeAllocSize(LocVT.getTypeForEVT(State.getContext())), 4);
 
153
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
 
154
    return false;
 
155
  }
 
156
 
 
157
  if (!State.isVarArg()) {
 
158
    if (LocVT == MVT::v16i8 ||
 
159
        LocVT == MVT::v8i16 ||
 
160
        LocVT == MVT::v4i32 ||
 
161
        LocVT == MVT::v2i64 ||
 
162
        LocVT == MVT::v4f32 ||
 
163
        LocVT == MVT::v2f64) {
 
164
      static const unsigned RegList6[] = {
 
165
        X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3
 
166
      };
 
167
      if (unsigned Reg = State.AllocateReg(RegList6, 4)) {
 
168
        State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
169
        return false;
 
170
      }
 
171
    }
 
172
  }
 
173
 
 
174
  if (LocVT == MVT::v16i8 ||
 
175
      LocVT == MVT::v8i16 ||
 
176
      LocVT == MVT::v4i32 ||
 
177
      LocVT == MVT::v2i64 ||
 
178
      LocVT == MVT::v4f32 ||
 
179
      LocVT == MVT::v2f64) {
 
180
    unsigned Offset7 = State.AllocateStack(16, 16);
 
181
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
 
182
    return false;
 
183
  }
 
184
 
 
185
  if (LocVT == MVT::v8i8 ||
 
186
      LocVT == MVT::v4i16 ||
 
187
      LocVT == MVT::v2i32 ||
 
188
      LocVT == MVT::v1i64) {
 
189
    unsigned Offset8 = State.AllocateStack(8, 4);
 
190
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset8, LocVT, LocInfo));
 
191
    return false;
 
192
  }
 
193
 
 
194
  return true;  // CC didn't match.
 
195
}
 
196
 
 
197
 
 
198
static bool CC_X86_32_FastCC(unsigned ValNo, EVT ValVT,
 
199
                             EVT LocVT, CCValAssign::LocInfo LocInfo,
 
200
                             ISD::ArgFlagsTy ArgFlags, CCState &State) {
 
201
 
 
202
  if (ArgFlags.isByVal()) {
 
203
    State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
 
204
    return false;
 
205
  }
 
206
 
 
207
  if (LocVT == MVT::i8 ||
 
208
      LocVT == MVT::i16) {
 
209
    LocVT = MVT::i32;
 
210
    if (ArgFlags.isSExt())
 
211
        LocInfo = CCValAssign::SExt;
 
212
    else if (ArgFlags.isZExt())
 
213
        LocInfo = CCValAssign::ZExt;
 
214
    else
 
215
        LocInfo = CCValAssign::AExt;
 
216
  }
 
217
 
 
218
  if (ArgFlags.isNest()) {
 
219
    if (unsigned Reg = State.AllocateReg(X86::EAX)) {
 
220
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
221
      return false;
 
222
    }
 
223
  }
 
224
 
 
225
  if (LocVT == MVT::i32) {
 
226
    static const unsigned RegList1[] = {
 
227
      X86::ECX, X86::EDX
 
228
    };
 
229
    if (unsigned Reg = State.AllocateReg(RegList1, 2)) {
 
230
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
231
      return false;
 
232
    }
 
233
  }
 
234
 
 
235
  if (!State.isVarArg()) {
 
236
    if (LocVT == MVT::f32 ||
 
237
        LocVT == MVT::f64) {
 
238
      if (State.getTarget().getSubtarget<X86Subtarget>().hasSSE2()) {
 
239
        static const unsigned RegList2[] = {
 
240
          X86::XMM0, X86::XMM1, X86::XMM2
 
241
        };
 
242
        if (unsigned Reg = State.AllocateReg(RegList2, 3)) {
 
243
          State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
244
          return false;
 
245
        }
 
246
      }
 
247
    }
 
248
  }
 
249
 
 
250
  if (LocVT == MVT::f64) {
 
251
    unsigned Offset3 = State.AllocateStack(8, 8);
 
252
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo));
 
253
    return false;
 
254
  }
 
255
 
 
256
  if (!CC_X86_32_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
 
257
    return false;
 
258
 
 
259
  return true;  // CC didn't match.
 
260
}
 
261
 
 
262
 
 
263
static bool CC_X86_32_FastCall(unsigned ValNo, EVT ValVT,
 
264
                               EVT LocVT, CCValAssign::LocInfo LocInfo,
 
265
                               ISD::ArgFlagsTy ArgFlags, CCState &State) {
 
266
 
 
267
  if (LocVT == MVT::i8 ||
 
268
      LocVT == MVT::i16) {
 
269
    LocVT = MVT::i32;
 
270
    if (ArgFlags.isSExt())
 
271
        LocInfo = CCValAssign::SExt;
 
272
    else if (ArgFlags.isZExt())
 
273
        LocInfo = CCValAssign::ZExt;
 
274
    else
 
275
        LocInfo = CCValAssign::AExt;
 
276
  }
 
277
 
 
278
  if (ArgFlags.isNest()) {
 
279
    if (unsigned Reg = State.AllocateReg(X86::EAX)) {
 
280
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
281
      return false;
 
282
    }
 
283
  }
 
284
 
 
285
  if (LocVT == MVT::i32) {
 
286
    static const unsigned RegList1[] = {
 
287
      X86::ECX, X86::EDX
 
288
    };
 
289
    if (unsigned Reg = State.AllocateReg(RegList1, 2)) {
 
290
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
291
      return false;
 
292
    }
 
293
  }
 
294
 
 
295
  if (!CC_X86_32_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
 
296
    return false;
 
297
 
 
298
  return true;  // CC didn't match.
 
299
}
 
300
 
 
301
 
 
302
static bool CC_X86_64_C(unsigned ValNo, EVT ValVT,
 
303
                        EVT LocVT, CCValAssign::LocInfo LocInfo,
 
304
                        ISD::ArgFlagsTy ArgFlags, CCState &State) {
 
305
 
 
306
  if (ArgFlags.isByVal()) {
 
307
    State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 8, 8, ArgFlags);
 
308
    return false;
 
309
  }
 
310
 
 
311
  if (LocVT == MVT::i8 ||
 
312
      LocVT == MVT::i16) {
 
313
    LocVT = MVT::i32;
 
314
    if (ArgFlags.isSExt())
 
315
        LocInfo = CCValAssign::SExt;
 
316
    else if (ArgFlags.isZExt())
 
317
        LocInfo = CCValAssign::ZExt;
 
318
    else
 
319
        LocInfo = CCValAssign::AExt;
 
320
  }
 
321
 
 
322
  if (ArgFlags.isNest()) {
 
323
    if (unsigned Reg = State.AllocateReg(X86::R10)) {
 
324
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
325
      return false;
 
326
    }
 
327
  }
 
328
 
 
329
  if (LocVT == MVT::v1i64) {
 
330
    if (State.getTarget().getSubtarget<X86Subtarget>().isTargetDarwin()) {
 
331
      LocVT = MVT::i64;
 
332
      LocInfo = CCValAssign::BCvt;
 
333
    }
 
334
  }
 
335
 
 
336
  if (LocVT == MVT::i32) {
 
337
    static const unsigned RegList1[] = {
 
338
      X86::EDI, X86::ESI, X86::EDX, X86::ECX, X86::R8D, X86::R9D
 
339
    };
 
340
    if (unsigned Reg = State.AllocateReg(RegList1, 6)) {
 
341
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
342
      return false;
 
343
    }
 
344
  }
 
345
 
 
346
  if (LocVT == MVT::i64) {
 
347
    static const unsigned RegList2[] = {
 
348
      X86::RDI, X86::RSI, X86::RDX, X86::RCX, X86::R8, X86::R9
 
349
    };
 
350
    if (unsigned Reg = State.AllocateReg(RegList2, 6)) {
 
351
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
352
      return false;
 
353
    }
 
354
  }
 
355
 
 
356
  if (LocVT == MVT::v8i8 ||
 
357
      LocVT == MVT::v4i16 ||
 
358
      LocVT == MVT::v2i32 ||
 
359
      LocVT == MVT::v2f32) {
 
360
    if (State.getTarget().getSubtarget<X86Subtarget>().isTargetDarwin()) {
 
361
      if (State.getTarget().getSubtarget<X86Subtarget>().hasSSE2()) {
 
362
        LocVT = MVT::v2i64;
 
363
        if (ArgFlags.isSExt())
 
364
                LocInfo = CCValAssign::SExt;
 
365
        else if (ArgFlags.isZExt())
 
366
                LocInfo = CCValAssign::ZExt;
 
367
        else
 
368
                LocInfo = CCValAssign::AExt;
 
369
      }
 
370
    }
 
371
  }
 
372
 
 
373
  if (LocVT == MVT::f32 ||
 
374
      LocVT == MVT::f64 ||
 
375
      LocVT == MVT::v16i8 ||
 
376
      LocVT == MVT::v8i16 ||
 
377
      LocVT == MVT::v4i32 ||
 
378
      LocVT == MVT::v2i64 ||
 
379
      LocVT == MVT::v4f32 ||
 
380
      LocVT == MVT::v2f64) {
 
381
    if (State.getTarget().getSubtarget<X86Subtarget>().hasSSE1()) {
 
382
      static const unsigned RegList3[] = {
 
383
        X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3, X86::XMM4, X86::XMM5, X86::XMM6, X86::XMM7
 
384
      };
 
385
      if (unsigned Reg = State.AllocateReg(RegList3, 8)) {
 
386
        State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
387
        return false;
 
388
      }
 
389
    }
 
390
  }
 
391
 
 
392
  if (LocVT == MVT::i32 ||
 
393
      LocVT == MVT::i64 ||
 
394
      LocVT == MVT::f32 ||
 
395
      LocVT == MVT::f64) {
 
396
    unsigned Offset4 = State.AllocateStack(8, 8);
 
397
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo));
 
398
    return false;
 
399
  }
 
400
 
 
401
  if (LocVT == MVT::f80) {
 
402
    unsigned Offset5 = State.AllocateStack(
 
403
      State.getTarget().getTargetData()->getTypeAllocSize(LocVT.getTypeForEVT(State.getContext())), 
 
404
      State.getTarget().getTargetData()->getABITypeAlignment(LocVT.getTypeForEVT(State.getContext())));
 
405
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
 
406
    return false;
 
407
  }
 
408
 
 
409
  if (LocVT == MVT::v16i8 ||
 
410
      LocVT == MVT::v8i16 ||
 
411
      LocVT == MVT::v4i32 ||
 
412
      LocVT == MVT::v2i64 ||
 
413
      LocVT == MVT::v4f32 ||
 
414
      LocVT == MVT::v2f64) {
 
415
    unsigned Offset6 = State.AllocateStack(16, 16);
 
416
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset6, LocVT, LocInfo));
 
417
    return false;
 
418
  }
 
419
 
 
420
  if (LocVT == MVT::v8i8 ||
 
421
      LocVT == MVT::v4i16 ||
 
422
      LocVT == MVT::v2i32 ||
 
423
      LocVT == MVT::v1i64 ||
 
424
      LocVT == MVT::v2f32) {
 
425
    unsigned Offset7 = State.AllocateStack(8, 8);
 
426
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
 
427
    return false;
 
428
  }
 
429
 
 
430
  return true;  // CC didn't match.
 
431
}
 
432
 
 
433
 
 
434
static bool CC_X86_Win64_C(unsigned ValNo, EVT ValVT,
 
435
                           EVT LocVT, CCValAssign::LocInfo LocInfo,
 
436
                           ISD::ArgFlagsTy ArgFlags, CCState &State) {
 
437
 
 
438
  if (LocVT == MVT::i8 ||
 
439
      LocVT == MVT::i16) {
 
440
    LocVT = MVT::i32;
 
441
    if (ArgFlags.isSExt())
 
442
        LocInfo = CCValAssign::SExt;
 
443
    else if (ArgFlags.isZExt())
 
444
        LocInfo = CCValAssign::ZExt;
 
445
    else
 
446
        LocInfo = CCValAssign::AExt;
 
447
  }
 
448
 
 
449
  if (ArgFlags.isNest()) {
 
450
    if (unsigned Reg = State.AllocateReg(X86::R10)) {
 
451
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
452
      return false;
 
453
    }
 
454
  }
 
455
 
 
456
  if (LocVT == MVT::v16i8 ||
 
457
      LocVT == MVT::v8i16 ||
 
458
      LocVT == MVT::v4i32 ||
 
459
      LocVT == MVT::v2i64 ||
 
460
      LocVT == MVT::v4f32 ||
 
461
      LocVT == MVT::v2f64) {
 
462
    LocVT = MVT::i64;
 
463
    LocInfo = CCValAssign::Indirect;
 
464
  }
 
465
 
 
466
  if (LocVT == MVT::v8i8 ||
 
467
      LocVT == MVT::v4i16 ||
 
468
      LocVT == MVT::v2i32 ||
 
469
      LocVT == MVT::v1i64 ||
 
470
      LocVT == MVT::v2f32) {
 
471
    LocVT = MVT::i64;
 
472
    LocInfo = CCValAssign::BCvt;
 
473
  }
 
474
 
 
475
  if (LocVT == MVT::i32) {
 
476
    static const unsigned RegList1[] = {
 
477
      X86::ECX, X86::EDX, X86::R8D, X86::R9D
 
478
    };
 
479
    static const unsigned RegList2[] = {
 
480
      X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3
 
481
    };
 
482
    if (unsigned Reg = State.AllocateReg(RegList1, RegList2, 4)) {
 
483
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
484
      return false;
 
485
    }
 
486
  }
 
487
 
 
488
  if (LocVT == MVT::i64) {
 
489
    static const unsigned RegList3[] = {
 
490
      X86::RCX, X86::RDX, X86::R8, X86::R9
 
491
    };
 
492
    static const unsigned RegList4[] = {
 
493
      X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3
 
494
    };
 
495
    if (unsigned Reg = State.AllocateReg(RegList3, RegList4, 4)) {
 
496
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
497
      return false;
 
498
    }
 
499
  }
 
500
 
 
501
  if (LocVT == MVT::f32 ||
 
502
      LocVT == MVT::f64 ||
 
503
      LocVT == MVT::v16i8 ||
 
504
      LocVT == MVT::v8i16 ||
 
505
      LocVT == MVT::v4i32 ||
 
506
      LocVT == MVT::v2i64 ||
 
507
      LocVT == MVT::v4f32 ||
 
508
      LocVT == MVT::v2f64) {
 
509
    static const unsigned RegList5[] = {
 
510
      X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3
 
511
    };
 
512
    static const unsigned RegList6[] = {
 
513
      X86::RCX, X86::RDX, X86::R8, X86::R9
 
514
    };
 
515
    if (unsigned Reg = State.AllocateReg(RegList5, RegList6, 4)) {
 
516
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
517
      return false;
 
518
    }
 
519
  }
 
520
 
 
521
  if (LocVT == MVT::i32 ||
 
522
      LocVT == MVT::i64 ||
 
523
      LocVT == MVT::f32 ||
 
524
      LocVT == MVT::f64) {
 
525
    unsigned Offset7 = State.AllocateStack(8, 8);
 
526
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
 
527
    return false;
 
528
  }
 
529
 
 
530
  if (LocVT == MVT::f80) {
 
531
    unsigned Offset8 = State.AllocateStack(
 
532
      State.getTarget().getTargetData()->getTypeAllocSize(LocVT.getTypeForEVT(State.getContext())), 
 
533
      State.getTarget().getTargetData()->getABITypeAlignment(LocVT.getTypeForEVT(State.getContext())));
 
534
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset8, LocVT, LocInfo));
 
535
    return false;
 
536
  }
 
537
 
 
538
  if (LocVT == MVT::v8i8 ||
 
539
      LocVT == MVT::v4i16 ||
 
540
      LocVT == MVT::v2i32 ||
 
541
      LocVT == MVT::v1i64) {
 
542
    unsigned Offset9 = State.AllocateStack(8, 8);
 
543
    State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset9, LocVT, LocInfo));
 
544
    return false;
 
545
  }
 
546
 
 
547
  return true;  // CC didn't match.
 
548
}
 
549
 
 
550
 
 
551
static bool RetCC_X86(unsigned ValNo, EVT ValVT,
 
552
                      EVT LocVT, CCValAssign::LocInfo LocInfo,
 
553
                      ISD::ArgFlagsTy ArgFlags, CCState &State) {
 
554
 
 
555
  if (State.getTarget().getSubtarget<X86Subtarget>().is64Bit()) {
 
556
    if (!RetCC_X86_64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
 
557
      return false;
 
558
  }
 
559
 
 
560
  if (!RetCC_X86_32(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
 
561
    return false;
 
562
 
 
563
  return true;  // CC didn't match.
 
564
}
 
565
 
 
566
 
 
567
static bool RetCC_X86Common(unsigned ValNo, EVT ValVT,
 
568
                            EVT LocVT, CCValAssign::LocInfo LocInfo,
 
569
                            ISD::ArgFlagsTy ArgFlags, CCState &State) {
 
570
 
 
571
  if (LocVT == MVT::i8) {
 
572
    static const unsigned RegList1[] = {
 
573
      X86::AL, X86::DL
 
574
    };
 
575
    if (unsigned Reg = State.AllocateReg(RegList1, 2)) {
 
576
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
577
      return false;
 
578
    }
 
579
  }
 
580
 
 
581
  if (LocVT == MVT::i16) {
 
582
    static const unsigned RegList2[] = {
 
583
      X86::AX, X86::DX
 
584
    };
 
585
    if (unsigned Reg = State.AllocateReg(RegList2, 2)) {
 
586
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
587
      return false;
 
588
    }
 
589
  }
 
590
 
 
591
  if (LocVT == MVT::i32) {
 
592
    static const unsigned RegList3[] = {
 
593
      X86::EAX, X86::EDX
 
594
    };
 
595
    if (unsigned Reg = State.AllocateReg(RegList3, 2)) {
 
596
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
597
      return false;
 
598
    }
 
599
  }
 
600
 
 
601
  if (LocVT == MVT::i64) {
 
602
    static const unsigned RegList4[] = {
 
603
      X86::RAX, X86::RDX
 
604
    };
 
605
    if (unsigned Reg = State.AllocateReg(RegList4, 2)) {
 
606
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
607
      return false;
 
608
    }
 
609
  }
 
610
 
 
611
  if (LocVT == MVT::v16i8 ||
 
612
      LocVT == MVT::v8i16 ||
 
613
      LocVT == MVT::v4i32 ||
 
614
      LocVT == MVT::v2i64 ||
 
615
      LocVT == MVT::v4f32 ||
 
616
      LocVT == MVT::v2f64) {
 
617
    static const unsigned RegList5[] = {
 
618
      X86::XMM0, X86::XMM1, X86::XMM2, X86::XMM3
 
619
    };
 
620
    if (unsigned Reg = State.AllocateReg(RegList5, 4)) {
 
621
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
622
      return false;
 
623
    }
 
624
  }
 
625
 
 
626
  if (LocVT == MVT::v8i8 ||
 
627
      LocVT == MVT::v4i16 ||
 
628
      LocVT == MVT::v2i32 ||
 
629
      LocVT == MVT::v1i64 ||
 
630
      LocVT == MVT::v2f32) {
 
631
    if (unsigned Reg = State.AllocateReg(X86::MM0)) {
 
632
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
633
      return false;
 
634
    }
 
635
  }
 
636
 
 
637
  if (LocVT == MVT::f80) {
 
638
    static const unsigned RegList6[] = {
 
639
      X86::ST0, X86::ST1
 
640
    };
 
641
    if (unsigned Reg = State.AllocateReg(RegList6, 2)) {
 
642
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
643
      return false;
 
644
    }
 
645
  }
 
646
 
 
647
  return true;  // CC didn't match.
 
648
}
 
649
 
 
650
 
 
651
static bool RetCC_X86_32(unsigned ValNo, EVT ValVT,
 
652
                         EVT LocVT, CCValAssign::LocInfo LocInfo,
 
653
                         ISD::ArgFlagsTy ArgFlags, CCState &State) {
 
654
 
 
655
  if (State.getCallingConv() == CallingConv::Fast) {
 
656
    if (!RetCC_X86_32_Fast(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
 
657
      return false;
 
658
  }
 
659
 
 
660
  if (!RetCC_X86_32_C(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
 
661
    return false;
 
662
 
 
663
  return true;  // CC didn't match.
 
664
}
 
665
 
 
666
 
 
667
static bool RetCC_X86_32_C(unsigned ValNo, EVT ValVT,
 
668
                           EVT LocVT, CCValAssign::LocInfo LocInfo,
 
669
                           ISD::ArgFlagsTy ArgFlags, CCState &State) {
 
670
 
 
671
  if (ArgFlags.isInReg()) {
 
672
    if (State.getTarget().getSubtarget<X86Subtarget>().hasSSE2()) {
 
673
      if (LocVT == MVT::f32 ||
 
674
          LocVT == MVT::f64) {
 
675
        static const unsigned RegList1[] = {
 
676
          X86::XMM0, X86::XMM1, X86::XMM2
 
677
        };
 
678
        if (unsigned Reg = State.AllocateReg(RegList1, 3)) {
 
679
          State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
680
          return false;
 
681
        }
 
682
      }
 
683
    }
 
684
  }
 
685
 
 
686
  if (LocVT == MVT::f32 ||
 
687
      LocVT == MVT::f64) {
 
688
    static const unsigned RegList2[] = {
 
689
      X86::ST0, X86::ST1
 
690
    };
 
691
    if (unsigned Reg = State.AllocateReg(RegList2, 2)) {
 
692
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
693
      return false;
 
694
    }
 
695
  }
 
696
 
 
697
  if (!RetCC_X86Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
 
698
    return false;
 
699
 
 
700
  return true;  // CC didn't match.
 
701
}
 
702
 
 
703
 
 
704
static bool RetCC_X86_32_Fast(unsigned ValNo, EVT ValVT,
 
705
                              EVT LocVT, CCValAssign::LocInfo LocInfo,
 
706
                              ISD::ArgFlagsTy ArgFlags, CCState &State) {
 
707
 
 
708
  if (LocVT == MVT::f32) {
 
709
    if (State.getTarget().getSubtarget<X86Subtarget>().hasSSE2()) {
 
710
      static const unsigned RegList1[] = {
 
711
        X86::XMM0, X86::XMM1, X86::XMM2
 
712
      };
 
713
      if (unsigned Reg = State.AllocateReg(RegList1, 3)) {
 
714
        State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
715
        return false;
 
716
      }
 
717
    }
 
718
  }
 
719
 
 
720
  if (LocVT == MVT::f64) {
 
721
    if (State.getTarget().getSubtarget<X86Subtarget>().hasSSE2()) {
 
722
      static const unsigned RegList2[] = {
 
723
        X86::XMM0, X86::XMM1, X86::XMM2
 
724
      };
 
725
      if (unsigned Reg = State.AllocateReg(RegList2, 3)) {
 
726
        State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
727
        return false;
 
728
      }
 
729
    }
 
730
  }
 
731
 
 
732
  if (LocVT == MVT::i8) {
 
733
    static const unsigned RegList3[] = {
 
734
      X86::AL, X86::DL, X86::CL
 
735
    };
 
736
    if (unsigned Reg = State.AllocateReg(RegList3, 3)) {
 
737
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
738
      return false;
 
739
    }
 
740
  }
 
741
 
 
742
  if (LocVT == MVT::i16) {
 
743
    static const unsigned RegList4[] = {
 
744
      X86::AX, X86::DX, X86::CX
 
745
    };
 
746
    if (unsigned Reg = State.AllocateReg(RegList4, 3)) {
 
747
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
748
      return false;
 
749
    }
 
750
  }
 
751
 
 
752
  if (LocVT == MVT::i32) {
 
753
    static const unsigned RegList5[] = {
 
754
      X86::EAX, X86::EDX, X86::ECX
 
755
    };
 
756
    if (unsigned Reg = State.AllocateReg(RegList5, 3)) {
 
757
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
758
      return false;
 
759
    }
 
760
  }
 
761
 
 
762
  if (!RetCC_X86Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
 
763
    return false;
 
764
 
 
765
  return true;  // CC didn't match.
 
766
}
 
767
 
 
768
 
 
769
static bool RetCC_X86_64(unsigned ValNo, EVT ValVT,
 
770
                         EVT LocVT, CCValAssign::LocInfo LocInfo,
 
771
                         ISD::ArgFlagsTy ArgFlags, CCState &State) {
 
772
 
 
773
  if (State.getTarget().getSubtarget<X86Subtarget>().isTargetWin64()) {
 
774
    if (!RetCC_X86_Win64_C(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
 
775
      return false;
 
776
  }
 
777
 
 
778
  if (!RetCC_X86_64_C(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
 
779
    return false;
 
780
 
 
781
  return true;  // CC didn't match.
 
782
}
 
783
 
 
784
 
 
785
static bool RetCC_X86_64_C(unsigned ValNo, EVT ValVT,
 
786
                           EVT LocVT, CCValAssign::LocInfo LocInfo,
 
787
                           ISD::ArgFlagsTy ArgFlags, CCState &State) {
 
788
 
 
789
  if (LocVT == MVT::f32) {
 
790
    static const unsigned RegList1[] = {
 
791
      X86::XMM0, X86::XMM1
 
792
    };
 
793
    if (unsigned Reg = State.AllocateReg(RegList1, 2)) {
 
794
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
795
      return false;
 
796
    }
 
797
  }
 
798
 
 
799
  if (LocVT == MVT::f64) {
 
800
    static const unsigned RegList2[] = {
 
801
      X86::XMM0, X86::XMM1
 
802
    };
 
803
    if (unsigned Reg = State.AllocateReg(RegList2, 2)) {
 
804
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
805
      return false;
 
806
    }
 
807
  }
 
808
 
 
809
  if (LocVT == MVT::v1i64) {
 
810
    if (unsigned Reg = State.AllocateReg(X86::RAX)) {
 
811
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
812
      return false;
 
813
    }
 
814
  }
 
815
 
 
816
  if (LocVT == MVT::v8i8 ||
 
817
      LocVT == MVT::v4i16 ||
 
818
      LocVT == MVT::v2i32 ||
 
819
      LocVT == MVT::v2f32) {
 
820
    static const unsigned RegList3[] = {
 
821
      X86::XMM0, X86::XMM1
 
822
    };
 
823
    if (unsigned Reg = State.AllocateReg(RegList3, 2)) {
 
824
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
825
      return false;
 
826
    }
 
827
  }
 
828
 
 
829
  if (!RetCC_X86Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
 
830
    return false;
 
831
 
 
832
  return true;  // CC didn't match.
 
833
}
 
834
 
 
835
 
 
836
static bool RetCC_X86_Win64_C(unsigned ValNo, EVT ValVT,
 
837
                              EVT LocVT, CCValAssign::LocInfo LocInfo,
 
838
                              ISD::ArgFlagsTy ArgFlags, CCState &State) {
 
839
 
 
840
  if (LocVT == MVT::v8i8 ||
 
841
      LocVT == MVT::v4i16 ||
 
842
      LocVT == MVT::v2i32 ||
 
843
      LocVT == MVT::v1i64) {
 
844
    LocVT = MVT::i64;
 
845
    LocInfo = CCValAssign::BCvt;
 
846
  }
 
847
 
 
848
  if (LocVT == MVT::f32) {
 
849
    if (unsigned Reg = State.AllocateReg(X86::XMM0)) {
 
850
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
851
      return false;
 
852
    }
 
853
  }
 
854
 
 
855
  if (LocVT == MVT::f64) {
 
856
    if (unsigned Reg = State.AllocateReg(X86::XMM0)) {
 
857
      State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
 
858
      return false;
 
859
    }
 
860
  }
 
861
 
 
862
  if (!RetCC_X86_64_C(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
 
863
    return false;
 
864
 
 
865
  return true;  // CC didn't match.
 
866
}