TargetInfo.cpp revision 5f9e272e632e951b1efe824cd16acb4d96077930 
1//===--- TargetInfo.cpp - Information about Target machine ----------------===//
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 TargetInfo and TargetInfoImpl interfaces.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Basic/AddressSpaces.h"
15#include "clang/Basic/TargetInfo.h"
16#include "clang/Basic/LangOptions.h"
17#include "llvm/ADT/APFloat.h"
18#include "llvm/ADT/STLExtras.h"
19#include <cctype>
20#include <cstdlib>
21using namespace clang;
22
23static const LangAS::Map DefaultAddrSpaceMap = { 0 };
24
25// TargetInfo Constructor.
26TargetInfo::TargetInfo(const std::string &T) : Triple(T) {
27  // Set defaults.  Defaults are set for a 32-bit RISC platform, like PPC or
28  // SPARC.  These should be overridden by concrete targets as needed.
29  TLSSupported = true;
30  NoAsmVariants = false;
31  PointerWidth = PointerAlign = 32;
32  BoolWidth = BoolAlign = 8;
33  IntWidth = IntAlign = 32;
34  LongWidth = LongAlign = 32;
35  LongLongWidth = LongLongAlign = 64;
36  FloatWidth = 32;
37  FloatAlign = 32;
38  DoubleWidth = 64;
39  DoubleAlign = 64;
40  LongDoubleWidth = 64;
41  LongDoubleAlign = 64;
42  LargeArrayMinWidth = 0;
43  LargeArrayAlign = 0;
44  SizeType = UnsignedLong;
45  PtrDiffType = SignedLong;
46  IntMaxType = SignedLongLong;
47  UIntMaxType = UnsignedLongLong;
48  IntPtrType = SignedLong;
49  WCharType = SignedInt;
50  WIntType = SignedInt;
51  Char16Type = UnsignedShort;
52  Char32Type = UnsignedInt;
53  Int64Type = SignedLongLong;
54  SigAtomicType = SignedInt;
55  UseBitFieldTypeAlignment = true;
56  FloatFormat = &llvm::APFloat::IEEEsingle;
57  DoubleFormat = &llvm::APFloat::IEEEdouble;
58  LongDoubleFormat = &llvm::APFloat::IEEEdouble;
59  DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
60                      "i64:64:64-f32:32:32-f64:64:64-n32";
61  UserLabelPrefix = "_";
62  MCountName = "mcount";
63  HasAlignMac68kSupport = false;
64
65  // Default to no types using fpret.
66  RealTypeUsesObjCFPRet = 0;
67
68  // Default to using the Itanium ABI.
69  CXXABI = CXXABI_Itanium;
70
71  // Default to an empty address space map.
72  AddrSpaceMap = &DefaultAddrSpaceMap;
73
74  // Default to an unknown platform name.
75  PlatformName = "unknown";
76  PlatformMinVersion = VersionTuple();
77}
78
79// Out of line virtual dtor for TargetInfo.
80TargetInfo::~TargetInfo() {}
81
82/// getTypeName - Return the user string for the specified integer type enum.
83/// For example, SignedShort -> "short".
84const char *TargetInfo::getTypeName(IntType T) {
85  switch (T) {
86  default: assert(0 && "not an integer!");
87  case SignedShort:      return "short";
88  case UnsignedShort:    return "unsigned short";
89  case SignedInt:        return "int";
90  case UnsignedInt:      return "unsigned int";
91  case SignedLong:       return "long int";
92  case UnsignedLong:     return "long unsigned int";
93  case SignedLongLong:   return "long long int";
94  case UnsignedLongLong: return "long long unsigned int";
95  }
96}
97
98/// getTypeConstantSuffix - Return the constant suffix for the specified
99/// integer type enum. For example, SignedLong -> "L".
100const char *TargetInfo::getTypeConstantSuffix(IntType T) {
101  switch (T) {
102  default: assert(0 && "not an integer!");
103  case SignedShort:
104  case SignedInt:        return "";
105  case SignedLong:       return "L";
106  case SignedLongLong:   return "LL";
107  case UnsignedShort:
108  case UnsignedInt:      return "U";
109  case UnsignedLong:     return "UL";
110  case UnsignedLongLong: return "ULL";
111  }
112}
113
114/// getTypeWidth - Return the width (in bits) of the specified integer type
115/// enum. For example, SignedInt -> getIntWidth().
116unsigned TargetInfo::getTypeWidth(IntType T) const {
117  switch (T) {
118  default: assert(0 && "not an integer!");
119  case SignedShort:
120  case UnsignedShort:    return getShortWidth();
121  case SignedInt:
122  case UnsignedInt:      return getIntWidth();
123  case SignedLong:
124  case UnsignedLong:     return getLongWidth();
125  case SignedLongLong:
126  case UnsignedLongLong: return getLongLongWidth();
127  };
128}
129
130/// getTypeAlign - Return the alignment (in bits) of the specified integer type
131/// enum. For example, SignedInt -> getIntAlign().
132unsigned TargetInfo::getTypeAlign(IntType T) const {
133  switch (T) {
134  default: assert(0 && "not an integer!");
135  case SignedShort:
136  case UnsignedShort:    return getShortAlign();
137  case SignedInt:
138  case UnsignedInt:      return getIntAlign();
139  case SignedLong:
140  case UnsignedLong:     return getLongAlign();
141  case SignedLongLong:
142  case UnsignedLongLong: return getLongLongAlign();
143  };
144}
145
146/// isTypeSigned - Return whether an integer types is signed. Returns true if
147/// the type is signed; false otherwise.
148bool TargetInfo::isTypeSigned(IntType T) {
149  switch (T) {
150  default: assert(0 && "not an integer!");
151  case SignedShort:
152  case SignedInt:
153  case SignedLong:
154  case SignedLongLong:
155    return true;
156  case UnsignedShort:
157  case UnsignedInt:
158  case UnsignedLong:
159  case UnsignedLongLong:
160    return false;
161  };
162}
163
164/// setForcedLangOptions - Set forced language options.
165/// Apply changes to the target information with respect to certain
166/// language options which change the target configuration.
167void TargetInfo::setForcedLangOptions(LangOptions &Opts) {
168  if (Opts.NoBitFieldTypeAlign)
169    UseBitFieldTypeAlignment = false;
170  if (Opts.ShortWChar)
171    WCharType = UnsignedShort;
172}
173
174//===----------------------------------------------------------------------===//
175
176
177static StringRef removeGCCRegisterPrefix(StringRef Name) {
178  if (Name[0] == '%' || Name[0] == '#')
179    Name = Name.substr(1);
180
181  return Name;
182}
183
184/// isValidClobber - Returns whether the passed in string is
185/// a valid clobber in an inline asm statement. This is used by
186/// Sema.
187bool TargetInfo::isValidClobber(StringRef Name) const {
188  return (isValidGCCRegisterName(Name) ||
189	  Name == "memory" || Name == "cc");
190}
191
192/// isValidGCCRegisterName - Returns whether the passed in string
193/// is a valid register name according to GCC. This is used by Sema for
194/// inline asm statements.
195bool TargetInfo::isValidGCCRegisterName(StringRef Name) const {
196  if (Name.empty())
197    return false;
198
199  const char * const *Names;
200  unsigned NumNames;
201
202  // Get rid of any register prefix.
203  Name = removeGCCRegisterPrefix(Name);
204
205  getGCCRegNames(Names, NumNames);
206
207  // If we have a number it maps to an entry in the register name array.
208  if (isdigit(Name[0])) {
209    int n;
210    if (!Name.getAsInteger(0, n))
211      return n >= 0 && (unsigned)n < NumNames;
212  }
213
214  // Check register names.
215  for (unsigned i = 0; i < NumNames; i++) {
216    if (Name == Names[i])
217      return true;
218  }
219
220  // Check any additional names that we have.
221  const AddlRegName *AddlNames;
222  unsigned NumAddlNames;
223  getGCCAddlRegNames(AddlNames, NumAddlNames);
224  for (unsigned i = 0; i < NumAddlNames; i++)
225    for (unsigned j = 0; j < llvm::array_lengthof(AddlNames[i].Names); j++) {
226      if (!AddlNames[i].Names[j])
227	break;
228      // Make sure the register that the additional name is for is within
229      // the bounds of the register names from above.
230      if (AddlNames[i].Names[j] == Name && AddlNames[i].RegNum < NumNames)
231	return true;
232  }
233
234  // Now check aliases.
235  const GCCRegAlias *Aliases;
236  unsigned NumAliases;
237
238  getGCCRegAliases(Aliases, NumAliases);
239  for (unsigned i = 0; i < NumAliases; i++) {
240    for (unsigned j = 0 ; j < llvm::array_lengthof(Aliases[i].Aliases); j++) {
241      if (!Aliases[i].Aliases[j])
242        break;
243      if (Aliases[i].Aliases[j] == Name)
244        return true;
245    }
246  }
247
248  return false;
249}
250
251StringRef
252TargetInfo::getNormalizedGCCRegisterName(StringRef Name) const {
253  assert(isValidGCCRegisterName(Name) && "Invalid register passed in");
254
255  // Get rid of any register prefix.
256  Name = removeGCCRegisterPrefix(Name);
257
258  const char * const *Names;
259  unsigned NumNames;
260
261  getGCCRegNames(Names, NumNames);
262
263  // First, check if we have a number.
264  if (isdigit(Name[0])) {
265    int n;
266    if (!Name.getAsInteger(0, n)) {
267      assert(n >= 0 && (unsigned)n < NumNames &&
268             "Out of bounds register number!");
269      return Names[n];
270    }
271  }
272
273  // Check any additional names that we have.
274  const AddlRegName *AddlNames;
275  unsigned NumAddlNames;
276  getGCCAddlRegNames(AddlNames, NumAddlNames);
277  for (unsigned i = 0; i < NumAddlNames; i++)
278    for (unsigned j = 0; j < llvm::array_lengthof(AddlNames[i].Names); j++) {
279      if (!AddlNames[i].Names[j])
280	break;
281      // Make sure the register that the additional name is for is within
282      // the bounds of the register names from above.
283      if (AddlNames[i].Names[j] == Name && AddlNames[i].RegNum < NumNames)
284	return Name;
285    }
286
287  // Now check aliases.
288  const GCCRegAlias *Aliases;
289  unsigned NumAliases;
290
291  getGCCRegAliases(Aliases, NumAliases);
292  for (unsigned i = 0; i < NumAliases; i++) {
293    for (unsigned j = 0 ; j < llvm::array_lengthof(Aliases[i].Aliases); j++) {
294      if (!Aliases[i].Aliases[j])
295        break;
296      if (Aliases[i].Aliases[j] == Name)
297        return Aliases[i].Register;
298    }
299  }
300
301  return Name;
302}
303
304bool TargetInfo::validateOutputConstraint(ConstraintInfo &Info) const {
305  const char *Name = Info.getConstraintStr().c_str();
306  // An output constraint must start with '=' or '+'
307  if (*Name != '=' && *Name != '+')
308    return false;
309
310  if (*Name == '+')
311    Info.setIsReadWrite();
312
313  Name++;
314  while (*Name) {
315    switch (*Name) {
316    default:
317      if (!validateAsmConstraint(Name, Info)) {
318        // FIXME: We temporarily return false
319        // so we can add more constraints as we hit it.
320        // Eventually, an unknown constraint should just be treated as 'g'.
321        return false;
322      }
323    case '&': // early clobber.
324      break;
325    case '%': // commutative.
326      // FIXME: Check that there is a another register after this one.
327      break;
328    case 'r': // general register.
329      Info.setAllowsRegister();
330      break;
331    case 'm': // memory operand.
332    case 'o': // offsetable memory operand.
333    case 'V': // non-offsetable memory operand.
334    case '<': // autodecrement memory operand.
335    case '>': // autoincrement memory operand.
336      Info.setAllowsMemory();
337      break;
338    case 'g': // general register, memory operand or immediate integer.
339    case 'X': // any operand.
340      Info.setAllowsRegister();
341      Info.setAllowsMemory();
342      break;
343    case ',': // multiple alternative constraint.  Pass it.
344      // Handle additional optional '=' or '+' modifiers.
345      if (Name[1] == '=' || Name[1] == '+')
346        Name++;
347      break;
348    case '?': // Disparage slightly code.
349    case '!': // Disparage severely.
350      break;  // Pass them.
351    }
352
353    Name++;
354  }
355
356  return true;
357}
358
359bool TargetInfo::resolveSymbolicName(const char *&Name,
360                                     ConstraintInfo *OutputConstraints,
361                                     unsigned NumOutputs,
362                                     unsigned &Index) const {
363  assert(*Name == '[' && "Symbolic name did not start with '['");
364  Name++;
365  const char *Start = Name;
366  while (*Name && *Name != ']')
367    Name++;
368
369  if (!*Name) {
370    // Missing ']'
371    return false;
372  }
373
374  std::string SymbolicName(Start, Name - Start);
375
376  for (Index = 0; Index != NumOutputs; ++Index)
377    if (SymbolicName == OutputConstraints[Index].getName())
378      return true;
379
380  return false;
381}
382
383bool TargetInfo::validateInputConstraint(ConstraintInfo *OutputConstraints,
384                                         unsigned NumOutputs,
385                                         ConstraintInfo &Info) const {
386  const char *Name = Info.ConstraintStr.c_str();
387
388  while (*Name) {
389    switch (*Name) {
390    default:
391      // Check if we have a matching constraint
392      if (*Name >= '0' && *Name <= '9') {
393        unsigned i = *Name - '0';
394
395        // Check if matching constraint is out of bounds.
396        if (i >= NumOutputs)
397          return false;
398
399        // A number must refer to an output only operand.
400        if (OutputConstraints[i].isReadWrite())
401          return false;
402
403        // If the constraint is already tied, it must be tied to the
404        // same operand referenced to by the number.
405        if (Info.hasTiedOperand() && Info.getTiedOperand() != i)
406          return false;
407
408        // The constraint should have the same info as the respective
409        // output constraint.
410        Info.setTiedOperand(i, OutputConstraints[i]);
411      } else if (!validateAsmConstraint(Name, Info)) {
412        // FIXME: This error return is in place temporarily so we can
413        // add more constraints as we hit it.  Eventually, an unknown
414        // constraint should just be treated as 'g'.
415        return false;
416      }
417      break;
418    case '[': {
419      unsigned Index = 0;
420      if (!resolveSymbolicName(Name, OutputConstraints, NumOutputs, Index))
421        return false;
422
423      // If the constraint is already tied, it must be tied to the
424      // same operand referenced to by the number.
425      if (Info.hasTiedOperand() && Info.getTiedOperand() != Index)
426        return false;
427
428      Info.setTiedOperand(Index, OutputConstraints[Index]);
429      break;
430    }
431    case '%': // commutative
432      // FIXME: Fail if % is used with the last operand.
433      break;
434    case 'i': // immediate integer.
435    case 'n': // immediate integer with a known value.
436      break;
437    case 'I':  // Various constant constraints with target-specific meanings.
438    case 'J':
439    case 'K':
440    case 'L':
441    case 'M':
442    case 'N':
443    case 'O':
444    case 'P':
445      break;
446    case 'r': // general register.
447      Info.setAllowsRegister();
448      break;
449    case 'm': // memory operand.
450    case 'o': // offsettable memory operand.
451    case 'V': // non-offsettable memory operand.
452    case '<': // autodecrement memory operand.
453    case '>': // autoincrement memory operand.
454      Info.setAllowsMemory();
455      break;
456    case 'g': // general register, memory operand or immediate integer.
457    case 'X': // any operand.
458      Info.setAllowsRegister();
459      Info.setAllowsMemory();
460      break;
461    case 'E': // immediate floating point.
462    case 'F': // immediate floating point.
463    case 'p': // address operand.
464      break;
465    case ',': // multiple alternative constraint.  Ignore comma.
466      break;
467    case '?': // Disparage slightly code.
468    case '!': // Disparage severely.
469      break;  // Pass them.
470    }
471
472    Name++;
473  }
474
475  return true;
476}
477