← Back to branch summary

~ubuntu-branches/ubuntu/maverick/clamav/maverick-backports

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Stephen Gran, Stephen Gran, Michael Tautschnig
  • Date: 2010-04-26 21:41:18 UTC
  • mfrom: (2.1.6 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100426214118-i6lo606wnh7ywfj6
Tags: 0.96+dfsg-4
http://bugs.debian.org/579271
http://bugs.debian.org/579068
[ Stephen Gran ]
* Fixed typo in clamav-milter's postinst

[ Michael Tautschnig ]
* Fixed typo in clamav-freshclam's postinst (closes: #579271)
* Debconf translation updates
  - Portuguese (closes: #579068)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/Target/SubtargetFeature.cpp
 
1
//===- SubtargetFeature.cpp - CPU characteristics Implementation ----------===//
 
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 implements the SubtargetFeature interface.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#include "llvm/Target/SubtargetFeature.h"
 
15
#include "llvm/Support/Debug.h"
 
16
#include "llvm/Support/raw_ostream.h"
 
17
#include "llvm/ADT/StringExtras.h"
 
18
#include <algorithm>
 
19
#include <cassert>
 
20
#include <cctype>
 
21
using namespace llvm;
 
22
 
 
23
//===----------------------------------------------------------------------===//
 
24
//                          Static Helper Functions
 
25
//===----------------------------------------------------------------------===//
 
26
 
 
27
/// hasFlag - Determine if a feature has a flag; '+' or '-'
 
28
///
 
29
static inline bool hasFlag(const std::string &Feature) {
 
30
  assert(!Feature.empty() && "Empty string");
 
31
  // Get first character
 
32
  char Ch = Feature[0];
 
33
  // Check if first character is '+' or '-' flag
 
34
  return Ch == '+' || Ch =='-';
 
35
}
 
36
 
 
37
/// StripFlag - Return string stripped of flag.
 
38
///
 
39
static inline std::string StripFlag(const std::string &Feature) {
 
40
  return hasFlag(Feature) ? Feature.substr(1) : Feature;
 
41
}
 
42
 
 
43
/// isEnabled - Return true if enable flag; '+'.
 
44
///
 
45
static inline bool isEnabled(const std::string &Feature) {
 
46
  assert(!Feature.empty() && "Empty string");
 
47
  // Get first character
 
48
  char Ch = Feature[0];
 
49
  // Check if first character is '+' for enabled
 
50
  return Ch == '+';
 
51
}
 
52
 
 
53
/// PrependFlag - Return a string with a prepended flag; '+' or '-'.
 
54
///
 
55
static inline std::string PrependFlag(const std::string &Feature,
 
56
                                      bool IsEnabled) {
 
57
  assert(!Feature.empty() && "Empty string");
 
58
  if (hasFlag(Feature)) return Feature;
 
59
  return std::string(IsEnabled ? "+" : "-") + Feature;
 
60
}
 
61
 
 
62
/// Split - Splits a string of comma separated items in to a vector of strings.
 
63
///
 
64
static void Split(std::vector<std::string> &V, const std::string &S) {
 
65
  // Start at beginning of string.
 
66
  size_t Pos = 0;
 
67
  while (true) {
 
68
    // Find the next comma
 
69
    size_t Comma = S.find(',', Pos);
 
70
    // If no comma found then the rest of the string is used
 
71
    if (Comma == std::string::npos) {
 
72
      // Add string to vector
 
73
      V.push_back(S.substr(Pos));
 
74
      break;
 
75
    }
 
76
    // Otherwise add substring to vector
 
77
    V.push_back(S.substr(Pos, Comma - Pos));
 
78
    // Advance to next item
 
79
    Pos = Comma + 1;
 
80
  }
 
81
}
 
82
 
 
83
/// Join a vector of strings to a string with a comma separating each element.
 
84
///
 
85
static std::string Join(const std::vector<std::string> &V) {
 
86
  // Start with empty string.
 
87
  std::string Result;
 
88
  // If the vector is not empty 
 
89
  if (!V.empty()) {
 
90
    // Start with the CPU feature
 
91
    Result = V[0];
 
92
    // For each successive feature
 
93
    for (size_t i = 1; i < V.size(); i++) {
 
94
      // Add a comma
 
95
      Result += ",";
 
96
      // Add the feature
 
97
      Result += V[i];
 
98
    }
 
99
  }
 
100
  // Return the features string 
 
101
  return Result;
 
102
}
 
103
 
 
104
/// Adding features.
 
105
void SubtargetFeatures::AddFeature(const std::string &String,
 
106
                                   bool IsEnabled) {
 
107
  // Don't add empty features
 
108
  if (!String.empty()) {
 
109
    // Convert to lowercase, prepend flag and add to vector
 
110
    Features.push_back(PrependFlag(LowercaseString(String), IsEnabled));
 
111
  }
 
112
}
 
113
 
 
114
/// Find KV in array using binary search.
 
115
template<typename T> const T *Find(const std::string &S, const T *A, size_t L) {
 
116
  // Make the lower bound element we're looking for
 
117
  T KV;
 
118
  KV.Key = S.c_str();
 
119
  // Determine the end of the array
 
120
  const T *Hi = A + L;
 
121
  // Binary search the array
 
122
  const T *F = std::lower_bound(A, Hi, KV);
 
123
  // If not found then return NULL
 
124
  if (F == Hi || std::string(F->Key) != S) return NULL;
 
125
  // Return the found array item
 
126
  return F;
 
127
}
 
128
 
 
129
/// getLongestEntryLength - Return the length of the longest entry in the table.
 
130
///
 
131
static size_t getLongestEntryLength(const SubtargetFeatureKV *Table,
 
132
                                    size_t Size) {
 
133
  size_t MaxLen = 0;
 
134
  for (size_t i = 0; i < Size; i++)
 
135
    MaxLen = std::max(MaxLen, std::strlen(Table[i].Key));
 
136
  return MaxLen;
 
137
}
 
138
 
 
139
/// Display help for feature choices.
 
140
///
 
141
static void Help(const SubtargetFeatureKV *CPUTable, size_t CPUTableSize,
 
142
                 const SubtargetFeatureKV *FeatTable, size_t FeatTableSize) {
 
143
  // Determine the length of the longest CPU and Feature entries.
 
144
  unsigned MaxCPULen  = getLongestEntryLength(CPUTable, CPUTableSize);
 
145
  unsigned MaxFeatLen = getLongestEntryLength(FeatTable, FeatTableSize);
 
146
 
 
147
  // Print the CPU table.
 
148
  errs() << "Available CPUs for this target:\n\n";
 
149
  for (size_t i = 0; i != CPUTableSize; i++)
 
150
    errs() << "  " << CPUTable[i].Key
 
151
         << std::string(MaxCPULen - std::strlen(CPUTable[i].Key), ' ')
 
152
         << " - " << CPUTable[i].Desc << ".\n";
 
153
  errs() << "\n";
 
154
  
 
155
  // Print the Feature table.
 
156
  errs() << "Available features for this target:\n\n";
 
157
  for (size_t i = 0; i != FeatTableSize; i++)
 
158
    errs() << "  " << FeatTable[i].Key
 
159
         << std::string(MaxFeatLen - std::strlen(FeatTable[i].Key), ' ')
 
160
         << " - " << FeatTable[i].Desc << ".\n";
 
161
  errs() << "\n";
 
162
  
 
163
  errs() << "Use +feature to enable a feature, or -feature to disable it.\n"
 
164
       << "For example, llc -mcpu=mycpu -mattr=+feature1,-feature2\n";
 
165
  exit(1);
 
166
}
 
167
 
 
168
//===----------------------------------------------------------------------===//
 
169
//                    SubtargetFeatures Implementation
 
170
//===----------------------------------------------------------------------===//
 
171
 
 
172
SubtargetFeatures::SubtargetFeatures(const std::string &Initial) {
 
173
  // Break up string into separate features
 
174
  Split(Features, Initial);
 
175
}
 
176
 
 
177
 
 
178
std::string SubtargetFeatures::getString() const {
 
179
  return Join(Features);
 
180
}
 
181
void SubtargetFeatures::setString(const std::string &Initial) {
 
182
  // Throw out old features
 
183
  Features.clear();
 
184
  // Break up string into separate features
 
185
  Split(Features, LowercaseString(Initial));
 
186
}
 
187
 
 
188
 
 
189
/// setCPU - Set the CPU string.  Replaces previous setting.  Setting to ""
 
190
/// clears CPU.
 
191
void SubtargetFeatures::setCPU(const std::string &String) {
 
192
  Features[0] = LowercaseString(String);
 
193
}
 
194
 
 
195
 
 
196
/// setCPUIfNone - Setting CPU string only if no string is set.
 
197
///
 
198
void SubtargetFeatures::setCPUIfNone(const std::string &String) {
 
199
  if (Features[0].empty()) setCPU(String);
 
200
}
 
201
 
 
202
/// getCPU - Returns current CPU.
 
203
///
 
204
const std::string & SubtargetFeatures::getCPU() const {
 
205
  return Features[0];
 
206
}
 
207
 
 
208
 
 
209
/// SetImpliedBits - For each feature that is (transitively) implied by this
 
210
/// feature, set it.
 
211
///
 
212
static
 
213
void SetImpliedBits(uint32_t &Bits, const SubtargetFeatureKV *FeatureEntry,
 
214
                    const SubtargetFeatureKV *FeatureTable,
 
215
                    size_t FeatureTableSize) {
 
216
  for (size_t i = 0; i < FeatureTableSize; ++i) {
 
217
    const SubtargetFeatureKV &FE = FeatureTable[i];
 
218
 
 
219
    if (FeatureEntry->Value == FE.Value) continue;
 
220
 
 
221
    if (FeatureEntry->Implies & FE.Value) {
 
222
      Bits |= FE.Value;
 
223
      SetImpliedBits(Bits, &FE, FeatureTable, FeatureTableSize);
 
224
    }
 
225
  }
 
226
}
 
227
 
 
228
/// ClearImpliedBits - For each feature that (transitively) implies this
 
229
/// feature, clear it.
 
230
/// 
 
231
static
 
232
void ClearImpliedBits(uint32_t &Bits, const SubtargetFeatureKV *FeatureEntry,
 
233
                      const SubtargetFeatureKV *FeatureTable,
 
234
                      size_t FeatureTableSize) {
 
235
  for (size_t i = 0; i < FeatureTableSize; ++i) {
 
236
    const SubtargetFeatureKV &FE = FeatureTable[i];
 
237
 
 
238
    if (FeatureEntry->Value == FE.Value) continue;
 
239
 
 
240
    if (FE.Implies & FeatureEntry->Value) {
 
241
      Bits &= ~FE.Value;
 
242
      ClearImpliedBits(Bits, &FE, FeatureTable, FeatureTableSize);
 
243
    }
 
244
  }
 
245
}
 
246
 
 
247
/// getBits - Get feature bits.
 
248
///
 
249
uint32_t SubtargetFeatures::getBits(const SubtargetFeatureKV *CPUTable,
 
250
                                          size_t CPUTableSize,
 
251
                                    const SubtargetFeatureKV *FeatureTable,
 
252
                                          size_t FeatureTableSize) {
 
253
  assert(CPUTable && "missing CPU table");
 
254
  assert(FeatureTable && "missing features table");
 
255
#ifndef NDEBUG
 
256
  for (size_t i = 1; i < CPUTableSize; i++) {
 
257
    assert(strcmp(CPUTable[i - 1].Key, CPUTable[i].Key) < 0 &&
 
258
           "CPU table is not sorted");
 
259
  }
 
260
  for (size_t i = 1; i < FeatureTableSize; i++) {
 
261
    assert(strcmp(FeatureTable[i - 1].Key, FeatureTable[i].Key) < 0 &&
 
262
          "CPU features table is not sorted");
 
263
  }
 
264
#endif
 
265
  uint32_t Bits = 0;                    // Resulting bits
 
266
 
 
267
  // Check if help is needed
 
268
  if (Features[0] == "help")
 
269
    Help(CPUTable, CPUTableSize, FeatureTable, FeatureTableSize);
 
270
  
 
271
  // Find CPU entry
 
272
  const SubtargetFeatureKV *CPUEntry =
 
273
                            Find(Features[0], CPUTable, CPUTableSize);
 
274
  // If there is a match
 
275
  if (CPUEntry) {
 
276
    // Set base feature bits
 
277
    Bits = CPUEntry->Value;
 
278
 
 
279
    // Set the feature implied by this CPU feature, if any.
 
280
    for (size_t i = 0; i < FeatureTableSize; ++i) {
 
281
      const SubtargetFeatureKV &FE = FeatureTable[i];
 
282
      if (CPUEntry->Value & FE.Value)
 
283
        SetImpliedBits(Bits, &FE, FeatureTable, FeatureTableSize);
 
284
    }
 
285
  } else {
 
286
    errs() << "'" << Features[0]
 
287
           << "' is not a recognized processor for this target"
 
288
           << " (ignoring processor)\n";
 
289
  }
 
290
  // Iterate through each feature
 
291
  for (size_t i = 1; i < Features.size(); i++) {
 
292
    const std::string &Feature = Features[i];
 
293
    
 
294
    // Check for help
 
295
    if (Feature == "+help")
 
296
      Help(CPUTable, CPUTableSize, FeatureTable, FeatureTableSize);
 
297
    
 
298
    // Find feature in table.
 
299
    const SubtargetFeatureKV *FeatureEntry =
 
300
                       Find(StripFlag(Feature), FeatureTable, FeatureTableSize);
 
301
    // If there is a match
 
302
    if (FeatureEntry) {
 
303
      // Enable/disable feature in bits
 
304
      if (isEnabled(Feature)) {
 
305
        Bits |=  FeatureEntry->Value;
 
306
 
 
307
        // For each feature that this implies, set it.
 
308
        SetImpliedBits(Bits, FeatureEntry, FeatureTable, FeatureTableSize);
 
309
      } else {
 
310
        Bits &= ~FeatureEntry->Value;
 
311
 
 
312
        // For each feature that implies this, clear it.
 
313
        ClearImpliedBits(Bits, FeatureEntry, FeatureTable, FeatureTableSize);
 
314
      }
 
315
    } else {
 
316
      errs() << "'" << Feature
 
317
             << "' is not a recognized feature for this target"
 
318
             << " (ignoring feature)\n";
 
319
    }
 
320
  }
 
321
 
 
322
  return Bits;
 
323
}
 
324
 
 
325
/// Get info pointer
 
326
void *SubtargetFeatures::getInfo(const SubtargetInfoKV *Table,
 
327
                                       size_t TableSize) {
 
328
  assert(Table && "missing table");
 
329
#ifndef NDEBUG
 
330
  for (size_t i = 1; i < TableSize; i++) {
 
331
    assert(strcmp(Table[i - 1].Key, Table[i].Key) < 0 && "Table is not sorted");
 
332
  }
 
333
#endif
 
334
 
 
335
  // Find entry
 
336
  const SubtargetInfoKV *Entry = Find(Features[0], Table, TableSize);
 
337
  
 
338
  if (Entry) {
 
339
    return Entry->Value;
 
340
  } else {
 
341
    errs() << "'" << Features[0]
 
342
           << "' is not a recognized processor for this target"
 
343
           << " (ignoring processor)\n";
 
344
    return NULL;
 
345
  }
 
346
}
 
347
 
 
348
/// print - Print feature string.
 
349
///
 
350
void SubtargetFeatures::print(raw_ostream &OS) const {
 
351
  for (size_t i = 0, e = Features.size(); i != e; ++i)
 
352
    OS << Features[i] << "  ";
 
353
  OS << "\n";
 
354
}
 
355
 
 
356
/// dump - Dump feature info.
 
357
///
 
358
void SubtargetFeatures::dump() const {
 
359
  print(dbgs());
 
360
}
 
361
 
 
362
/// getDefaultSubtargetFeatures - Return a string listing
 
363
/// the features associated with the target triple.
 
364
///
 
365
/// FIXME: This is an inelegant way of specifying the features of a
 
366
/// subtarget. It would be better if we could encode this information
 
367
/// into the IR. See <rdar://5972456>.
 
368
///
 
369
std::string SubtargetFeatures::getDefaultSubtargetFeatures(
 
370
                                               const Triple& Triple) {
 
371
  switch (Triple.getVendor()) {
 
372
  case Triple::Apple:
 
373
    switch (Triple.getArch()) {
 
374
    case Triple::ppc:   // powerpc-apple-*
 
375
      return std::string("altivec");
 
376
    case Triple::ppc64: // powerpc64-apple-*
 
377
      return std::string("64bit,altivec");
 
378
    default:
 
379
      break;
 
380
    }
 
381
    break;
 
382
  default:
 
383
    break;
 
384
  } 
 
385
 
 
386
  return std::string("");
 
387
}