clang  3.7.0
Basic/TargetInfo.cpp
Go to the documentation of this file.
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/TargetInfo.h"
16 #include "clang/Basic/CharInfo.h"
18 #include "llvm/ADT/APFloat.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/Support/ErrorHandling.h"
21 #include <cstdlib>
22 using namespace clang;
23 
24 static const LangAS::Map DefaultAddrSpaceMap = { 0 };
25 
26 // TargetInfo Constructor.
27 TargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), Triple(T) {
28  // Set defaults. Defaults are set for a 32-bit RISC platform, like PPC or
29  // SPARC. These should be overridden by concrete targets as needed.
30  BigEndian = true;
31  TLSSupported = true;
32  NoAsmVariants = false;
34  BoolWidth = BoolAlign = 8;
35  IntWidth = IntAlign = 32;
36  LongWidth = LongAlign = 32;
38  SuitableAlign = 64;
40  MinGlobalAlign = 0;
41  HalfWidth = 16;
42  HalfAlign = 16;
43  FloatWidth = 32;
44  FloatAlign = 32;
45  DoubleWidth = 64;
46  DoubleAlign = 64;
47  LongDoubleWidth = 64;
48  LongDoubleAlign = 64;
50  LargeArrayAlign = 0;
52  MaxVectorAlign = 0;
53  MaxTLSAlign = 0;
54  SimdDefaultAlign = 0;
70  HalfFormat = &llvm::APFloat::IEEEhalf;
71  FloatFormat = &llvm::APFloat::IEEEsingle;
72  DoubleFormat = &llvm::APFloat::IEEEdouble;
73  LongDoubleFormat = &llvm::APFloat::IEEEdouble;
74  DescriptionString = nullptr;
75  UserLabelPrefix = "_";
76  MCountName = "mcount";
77  RegParmMax = 0;
78  SSERegParmMax = 0;
79  HasAlignMac68kSupport = false;
80 
81  // Default to no types using fpret.
83 
84  // Default to not using fp2ret for __Complex long double
86 
87  // Set the C++ ABI based on the triple.
88  TheCXXABI.set(Triple.isKnownWindowsMSVCEnvironment()
91 
92  // Default to an empty address space map.
95 
96  // Default to an unknown platform name.
97  PlatformName = "unknown";
99 }
100 
101 // Out of line virtual dtor for TargetInfo.
103 
104 /// getTypeName - Return the user string for the specified integer type enum.
105 /// For example, SignedShort -> "short".
107  switch (T) {
108  default: llvm_unreachable("not an integer!");
109  case SignedChar: return "signed char";
110  case UnsignedChar: return "unsigned char";
111  case SignedShort: return "short";
112  case UnsignedShort: return "unsigned short";
113  case SignedInt: return "int";
114  case UnsignedInt: return "unsigned int";
115  case SignedLong: return "long int";
116  case UnsignedLong: return "long unsigned int";
117  case SignedLongLong: return "long long int";
118  case UnsignedLongLong: return "long long unsigned int";
119  }
120 }
121 
122 /// getTypeConstantSuffix - Return the constant suffix for the specified
123 /// integer type enum. For example, SignedLong -> "L".
125  switch (T) {
126  default: llvm_unreachable("not an integer!");
127  case SignedChar:
128  case SignedShort:
129  case SignedInt: return "";
130  case SignedLong: return "L";
131  case SignedLongLong: return "LL";
132  case UnsignedChar:
133  if (getCharWidth() < getIntWidth())
134  return "";
135  case UnsignedShort:
136  if (getShortWidth() < getIntWidth())
137  return "";
138  case UnsignedInt: return "U";
139  case UnsignedLong: return "UL";
140  case UnsignedLongLong: return "ULL";
141  }
142 }
143 
144 /// getTypeFormatModifier - Return the printf format modifier for the
145 /// specified integer type enum. For example, SignedLong -> "l".
146 
148  switch (T) {
149  default: llvm_unreachable("not an integer!");
150  case SignedChar:
151  case UnsignedChar: return "hh";
152  case SignedShort:
153  case UnsignedShort: return "h";
154  case SignedInt:
155  case UnsignedInt: return "";
156  case SignedLong:
157  case UnsignedLong: return "l";
158  case SignedLongLong:
159  case UnsignedLongLong: return "ll";
160  }
161 }
162 
163 /// getTypeWidth - Return the width (in bits) of the specified integer type
164 /// enum. For example, SignedInt -> getIntWidth().
166  switch (T) {
167  default: llvm_unreachable("not an integer!");
168  case SignedChar:
169  case UnsignedChar: return getCharWidth();
170  case SignedShort:
171  case UnsignedShort: return getShortWidth();
172  case SignedInt:
173  case UnsignedInt: return getIntWidth();
174  case SignedLong:
175  case UnsignedLong: return getLongWidth();
176  case SignedLongLong:
177  case UnsignedLongLong: return getLongLongWidth();
178  };
179 }
180 
182  unsigned BitWidth, bool IsSigned) const {
183  if (getCharWidth() == BitWidth)
184  return IsSigned ? SignedChar : UnsignedChar;
185  if (getShortWidth() == BitWidth)
186  return IsSigned ? SignedShort : UnsignedShort;
187  if (getIntWidth() == BitWidth)
188  return IsSigned ? SignedInt : UnsignedInt;
189  if (getLongWidth() == BitWidth)
190  return IsSigned ? SignedLong : UnsignedLong;
191  if (getLongLongWidth() == BitWidth)
192  return IsSigned ? SignedLongLong : UnsignedLongLong;
193  return NoInt;
194 }
195 
197  bool IsSigned) const {
198  if (getCharWidth() >= BitWidth)
199  return IsSigned ? SignedChar : UnsignedChar;
200  if (getShortWidth() >= BitWidth)
201  return IsSigned ? SignedShort : UnsignedShort;
202  if (getIntWidth() >= BitWidth)
203  return IsSigned ? SignedInt : UnsignedInt;
204  if (getLongWidth() >= BitWidth)
205  return IsSigned ? SignedLong : UnsignedLong;
206  if (getLongLongWidth() >= BitWidth)
207  return IsSigned ? SignedLongLong : UnsignedLongLong;
208  return NoInt;
209 }
210 
212  if (getFloatWidth() == BitWidth)
213  return Float;
214  if (getDoubleWidth() == BitWidth)
215  return Double;
216 
217  switch (BitWidth) {
218  case 96:
219  if (&getLongDoubleFormat() == &llvm::APFloat::x87DoubleExtended)
220  return LongDouble;
221  break;
222  case 128:
223  if (&getLongDoubleFormat() == &llvm::APFloat::PPCDoubleDouble ||
224  &getLongDoubleFormat() == &llvm::APFloat::IEEEquad)
225  return LongDouble;
226  break;
227  }
228 
229  return NoFloat;
230 }
231 
232 /// getTypeAlign - Return the alignment (in bits) of the specified integer type
233 /// enum. For example, SignedInt -> getIntAlign().
235  switch (T) {
236  default: llvm_unreachable("not an integer!");
237  case SignedChar:
238  case UnsignedChar: return getCharAlign();
239  case SignedShort:
240  case UnsignedShort: return getShortAlign();
241  case SignedInt:
242  case UnsignedInt: return getIntAlign();
243  case SignedLong:
244  case UnsignedLong: return getLongAlign();
245  case SignedLongLong:
246  case UnsignedLongLong: return getLongLongAlign();
247  };
248 }
249 
250 /// isTypeSigned - Return whether an integer types is signed. Returns true if
251 /// the type is signed; false otherwise.
253  switch (T) {
254  default: llvm_unreachable("not an integer!");
255  case SignedChar:
256  case SignedShort:
257  case SignedInt:
258  case SignedLong:
259  case SignedLongLong:
260  return true;
261  case UnsignedChar:
262  case UnsignedShort:
263  case UnsignedInt:
264  case UnsignedLong:
265  case UnsignedLongLong:
266  return false;
267  };
268 }
269 
270 /// adjust - Set forced language options.
271 /// Apply changes to the target information with respect to certain
272 /// language options which change the target configuration.
273 void TargetInfo::adjust(const LangOptions &Opts) {
274  if (Opts.NoBitFieldTypeAlign)
275  UseBitFieldTypeAlignment = false;
276  if (Opts.ShortWChar)
278 
279  if (Opts.OpenCL) {
280  // OpenCL C requires specific widths for types, irrespective of
281  // what these normally are for the target.
282  // We also define long long and long double here, although the
283  // OpenCL standard only mentions these as "reserved".
284  IntWidth = IntAlign = 32;
285  LongWidth = LongAlign = 64;
287  HalfWidth = HalfAlign = 16;
288  FloatWidth = FloatAlign = 32;
289 
290  // Embedded 32-bit targets (OpenCL EP) might have double C type
291  // defined as float. Let's not override this as it might lead
292  // to generating illegal code that uses 64bit doubles.
293  if (DoubleWidth != FloatWidth) {
294  DoubleWidth = DoubleAlign = 64;
295  DoubleFormat = &llvm::APFloat::IEEEdouble;
296  }
298 
299  assert(PointerWidth == 32 || PointerWidth == 64);
300  bool Is32BitArch = PointerWidth == 32;
301  SizeType = Is32BitArch ? UnsignedInt : UnsignedLong;
302  PtrDiffType = Is32BitArch ? SignedInt : SignedLong;
303  IntPtrType = Is32BitArch ? SignedInt : SignedLong;
304 
307 
308  HalfFormat = &llvm::APFloat::IEEEhalf;
309  FloatFormat = &llvm::APFloat::IEEEsingle;
310  LongDoubleFormat = &llvm::APFloat::IEEEquad;
311  }
312 }
313 
314 //===----------------------------------------------------------------------===//
315 
316 
317 static StringRef removeGCCRegisterPrefix(StringRef Name) {
318  if (Name[0] == '%' || Name[0] == '#')
319  Name = Name.substr(1);
320 
321  return Name;
322 }
323 
324 /// isValidClobber - Returns whether the passed in string is
325 /// a valid clobber in an inline asm statement. This is used by
326 /// Sema.
327 bool TargetInfo::isValidClobber(StringRef Name) const {
328  return (isValidGCCRegisterName(Name) ||
329  Name == "memory" || Name == "cc");
330 }
331 
332 /// isValidGCCRegisterName - Returns whether the passed in string
333 /// is a valid register name according to GCC. This is used by Sema for
334 /// inline asm statements.
335 bool TargetInfo::isValidGCCRegisterName(StringRef Name) const {
336  if (Name.empty())
337  return false;
338 
339  const char * const *Names;
340  unsigned NumNames;
341 
342  // Get rid of any register prefix.
343  Name = removeGCCRegisterPrefix(Name);
344  if (Name.empty())
345  return false;
346 
347  getGCCRegNames(Names, NumNames);
348 
349  // If we have a number it maps to an entry in the register name array.
350  if (isDigit(Name[0])) {
351  int n;
352  if (!Name.getAsInteger(0, n))
353  return n >= 0 && (unsigned)n < NumNames;
354  }
355 
356  // Check register names.
357  for (unsigned i = 0; i < NumNames; i++) {
358  if (Name == Names[i])
359  return true;
360  }
361 
362  // Check any additional names that we have.
363  const AddlRegName *AddlNames;
364  unsigned NumAddlNames;
365  getGCCAddlRegNames(AddlNames, NumAddlNames);
366  for (unsigned i = 0; i < NumAddlNames; i++)
367  for (unsigned j = 0; j < llvm::array_lengthof(AddlNames[i].Names); j++) {
368  if (!AddlNames[i].Names[j])
369  break;
370  // Make sure the register that the additional name is for is within
371  // the bounds of the register names from above.
372  if (AddlNames[i].Names[j] == Name && AddlNames[i].RegNum < NumNames)
373  return true;
374  }
375 
376  // Now check aliases.
377  const GCCRegAlias *Aliases;
378  unsigned NumAliases;
379 
380  getGCCRegAliases(Aliases, NumAliases);
381  for (unsigned i = 0; i < NumAliases; i++) {
382  for (unsigned j = 0 ; j < llvm::array_lengthof(Aliases[i].Aliases); j++) {
383  if (!Aliases[i].Aliases[j])
384  break;
385  if (Aliases[i].Aliases[j] == Name)
386  return true;
387  }
388  }
389 
390  return false;
391 }
392 
393 StringRef
395  assert(isValidGCCRegisterName(Name) && "Invalid register passed in");
396 
397  // Get rid of any register prefix.
398  Name = removeGCCRegisterPrefix(Name);
399 
400  const char * const *Names;
401  unsigned NumNames;
402 
403  getGCCRegNames(Names, NumNames);
404 
405  // First, check if we have a number.
406  if (isDigit(Name[0])) {
407  int n;
408  if (!Name.getAsInteger(0, n)) {
409  assert(n >= 0 && (unsigned)n < NumNames &&
410  "Out of bounds register number!");
411  return Names[n];
412  }
413  }
414 
415  // Check any additional names that we have.
416  const AddlRegName *AddlNames;
417  unsigned NumAddlNames;
418  getGCCAddlRegNames(AddlNames, NumAddlNames);
419  for (unsigned i = 0; i < NumAddlNames; i++)
420  for (unsigned j = 0; j < llvm::array_lengthof(AddlNames[i].Names); j++) {
421  if (!AddlNames[i].Names[j])
422  break;
423  // Make sure the register that the additional name is for is within
424  // the bounds of the register names from above.
425  if (AddlNames[i].Names[j] == Name && AddlNames[i].RegNum < NumNames)
426  return Name;
427  }
428 
429  // Now check aliases.
430  const GCCRegAlias *Aliases;
431  unsigned NumAliases;
432 
433  getGCCRegAliases(Aliases, NumAliases);
434  for (unsigned i = 0; i < NumAliases; i++) {
435  for (unsigned j = 0 ; j < llvm::array_lengthof(Aliases[i].Aliases); j++) {
436  if (!Aliases[i].Aliases[j])
437  break;
438  if (Aliases[i].Aliases[j] == Name)
439  return Aliases[i].Register;
440  }
441  }
442 
443  return Name;
444 }
445 
447  const char *Name = Info.getConstraintStr().c_str();
448  // An output constraint must start with '=' or '+'
449  if (*Name != '=' && *Name != '+')
450  return false;
451 
452  if (*Name == '+')
453  Info.setIsReadWrite();
454 
455  Name++;
456  while (*Name) {
457  switch (*Name) {
458  default:
459  if (!validateAsmConstraint(Name, Info)) {
460  // FIXME: We temporarily return false
461  // so we can add more constraints as we hit it.
462  // Eventually, an unknown constraint should just be treated as 'g'.
463  return false;
464  }
465  break;
466  case '&': // early clobber.
467  Info.setEarlyClobber();
468  break;
469  case '%': // commutative.
470  // FIXME: Check that there is a another register after this one.
471  break;
472  case 'r': // general register.
473  Info.setAllowsRegister();
474  break;
475  case 'm': // memory operand.
476  case 'o': // offsetable memory operand.
477  case 'V': // non-offsetable memory operand.
478  case '<': // autodecrement memory operand.
479  case '>': // autoincrement memory operand.
480  Info.setAllowsMemory();
481  break;
482  case 'g': // general register, memory operand or immediate integer.
483  case 'X': // any operand.
484  Info.setAllowsRegister();
485  Info.setAllowsMemory();
486  break;
487  case ',': // multiple alternative constraint. Pass it.
488  // Handle additional optional '=' or '+' modifiers.
489  if (Name[1] == '=' || Name[1] == '+')
490  Name++;
491  break;
492  case '#': // Ignore as constraint.
493  while (Name[1] && Name[1] != ',')
494  Name++;
495  break;
496  case '?': // Disparage slightly code.
497  case '!': // Disparage severely.
498  case '*': // Ignore for choosing register preferences.
499  break; // Pass them.
500  }
501 
502  Name++;
503  }
504 
505  // Early clobber with a read-write constraint which doesn't permit registers
506  // is invalid.
507  if (Info.earlyClobber() && Info.isReadWrite() && !Info.allowsRegister())
508  return false;
509 
510  // If a constraint allows neither memory nor register operands it contains
511  // only modifiers. Reject it.
512  return Info.allowsMemory() || Info.allowsRegister();
513 }
514 
515 bool TargetInfo::resolveSymbolicName(const char *&Name,
516  ConstraintInfo *OutputConstraints,
517  unsigned NumOutputs,
518  unsigned &Index) const {
519  assert(*Name == '[' && "Symbolic name did not start with '['");
520  Name++;
521  const char *Start = Name;
522  while (*Name && *Name != ']')
523  Name++;
524 
525  if (!*Name) {
526  // Missing ']'
527  return false;
528  }
529 
530  std::string SymbolicName(Start, Name - Start);
531 
532  for (Index = 0; Index != NumOutputs; ++Index)
533  if (SymbolicName == OutputConstraints[Index].getName())
534  return true;
535 
536  return false;
537 }
538 
540  unsigned NumOutputs,
541  ConstraintInfo &Info) const {
542  const char *Name = Info.ConstraintStr.c_str();
543 
544  if (!*Name)
545  return false;
546 
547  while (*Name) {
548  switch (*Name) {
549  default:
550  // Check if we have a matching constraint
551  if (*Name >= '0' && *Name <= '9') {
552  const char *DigitStart = Name;
553  while (Name[1] >= '0' && Name[1] <= '9')
554  Name++;
555  const char *DigitEnd = Name;
556  unsigned i;
557  if (StringRef(DigitStart, DigitEnd - DigitStart + 1)
558  .getAsInteger(10, i))
559  return false;
560 
561  // Check if matching constraint is out of bounds.
562  if (i >= NumOutputs) return false;
563 
564  // A number must refer to an output only operand.
565  if (OutputConstraints[i].isReadWrite())
566  return false;
567 
568  // If the constraint is already tied, it must be tied to the
569  // same operand referenced to by the number.
570  if (Info.hasTiedOperand() && Info.getTiedOperand() != i)
571  return false;
572 
573  // The constraint should have the same info as the respective
574  // output constraint.
575  Info.setTiedOperand(i, OutputConstraints[i]);
576  } else if (!validateAsmConstraint(Name, Info)) {
577  // FIXME: This error return is in place temporarily so we can
578  // add more constraints as we hit it. Eventually, an unknown
579  // constraint should just be treated as 'g'.
580  return false;
581  }
582  break;
583  case '[': {
584  unsigned Index = 0;
585  if (!resolveSymbolicName(Name, OutputConstraints, NumOutputs, Index))
586  return false;
587 
588  // If the constraint is already tied, it must be tied to the
589  // same operand referenced to by the number.
590  if (Info.hasTiedOperand() && Info.getTiedOperand() != Index)
591  return false;
592 
593  // A number must refer to an output only operand.
594  if (OutputConstraints[Index].isReadWrite())
595  return false;
596 
597  Info.setTiedOperand(Index, OutputConstraints[Index]);
598  break;
599  }
600  case '%': // commutative
601  // FIXME: Fail if % is used with the last operand.
602  break;
603  case 'i': // immediate integer.
604  case 'n': // immediate integer with a known value.
605  break;
606  case 'I': // Various constant constraints with target-specific meanings.
607  case 'J':
608  case 'K':
609  case 'L':
610  case 'M':
611  case 'N':
612  case 'O':
613  case 'P':
614  if (!validateAsmConstraint(Name, Info))
615  return false;
616  break;
617  case 'r': // general register.
618  Info.setAllowsRegister();
619  break;
620  case 'm': // memory operand.
621  case 'o': // offsettable memory operand.
622  case 'V': // non-offsettable memory operand.
623  case '<': // autodecrement memory operand.
624  case '>': // autoincrement memory operand.
625  Info.setAllowsMemory();
626  break;
627  case 'g': // general register, memory operand or immediate integer.
628  case 'X': // any operand.
629  Info.setAllowsRegister();
630  Info.setAllowsMemory();
631  break;
632  case 'E': // immediate floating point.
633  case 'F': // immediate floating point.
634  case 'p': // address operand.
635  break;
636  case ',': // multiple alternative constraint. Ignore comma.
637  break;
638  case '#': // Ignore as constraint.
639  while (Name[1] && Name[1] != ',')
640  Name++;
641  break;
642  case '?': // Disparage slightly code.
643  case '!': // Disparage severely.
644  case '*': // Ignore for choosing register preferences.
645  break; // Pass them.
646  }
647 
648  Name++;
649  }
650 
651  return true;
652 }
653 
654 bool TargetCXXABI::tryParse(llvm::StringRef name) {
655  const Kind unknown = static_cast<Kind>(-1);
656  Kind kind = llvm::StringSwitch<Kind>(name)
657  .Case("arm", GenericARM)
658  .Case("ios", iOS)
659  .Case("itanium", GenericItanium)
660  .Case("microsoft", Microsoft)
661  .Case("mips", GenericMIPS)
662  .Default(unknown);
663  if (kind == unknown) return false;
664 
665  set(kind);
666  return true;
667 }
RealType getRealTypeByWidth(unsigned BitWidth) const
Return floating point type with specified width.
static LLVM_READONLY bool isDigit(unsigned char c)
Return true if this character is an ASCII digit: [0-9].
Definition: CharInfo.h:94
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
bool resolveSymbolicName(const char *&Name, ConstraintInfo *OutputConstraints, unsigned NumOutputs, unsigned &Index) const
virtual bool validateAsmConstraint(const char *&Name, TargetInfo::ConstraintInfo &info) const =0
const llvm::fltSemantics * DoubleFormat
bool validateOutputConstraint(ConstraintInfo &Info) const
TargetInfo(const llvm::Triple &T)
virtual void adjust(const LangOptions &Opts)
Set forced language options.
unsigned getFloatWidth() const
getFloatWidth/Align/Format - Return the size/align/format of 'float'.
unsigned getDoubleWidth() const
getDoubleWidth/Align/Format - Return the size/align/format of 'double'.
const char * getTypeConstantSuffix(IntType T) const
Return the constant suffix for the specified integer type enum.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
static bool isTypeSigned(IntType T)
Returns true if the type is signed; false otherwise.
unsigned char DefaultAlignForAttributeAligned
bool isValidGCCRegisterName(StringRef Name) const
Returns whether the passed in string is a valid register name according to GCC.
static const LangAS::Map DefaultAddrSpaceMap
Provides definitions for the various language-specific address spaces.
unsigned getTypeWidth(IntType T) const
Return the width (in bits) of the specified integer type enum.
Defines the clang::LangOptions interface.
bool isValidClobber(StringRef Name) const
Returns whether the passed in string is a valid clobber in an inline asm statement.
static StringRef removeGCCRegisterPrefix(StringRef Name)
static const char * getTypeName(IntType T)
Return the user string for the specified integer type enum.
unsigned getTypeAlign(IntType T) const
Return the alignment (in bits) of the specified integer type enum.
const LangAS::Map * AddrSpaceMap
bool tryParse(llvm::StringRef name)
Try to parse an ABI name, returning false on error.
IntType getIntTypeByWidth(unsigned BitWidth, bool IsSigned) const
Return integer type with specified width.
unsigned UseZeroLengthBitfieldAlignment
Whether zero length bitfields (e.g., int : 0;) force alignment of the next bitfield.
void set(Kind kind)
Definition: TargetCXXABI.h:109
IntType
===-— Target Data Type Query Methods ----------------------------—===//
Kind
The basic C++ ABI kind.
Definition: TargetCXXABI.h:28
const llvm::fltSemantics & getLongDoubleFormat() const
static const char * getTypeFormatModifier(IntType T)
Return the printf format modifier for the specified integer type enum.
bool hasTiedOperand() const
Return true if this input operand is a matching constraint that ties it to an output operand...
unsigned getShortWidth() const
Return the size of 'signed short' and 'unsigned short' for this target, in bits.
IntType getLeastIntTypeByWidth(unsigned BitWidth, bool IsSigned) const
Return the smallest integer type with at least the specified width.
unsigned UseSignedCharForObjCBool
Whether Objective-C's built-in boolean type should be signed char.
virtual void getGCCRegAliases(const GCCRegAlias *&Aliases, unsigned &NumAliases) const =0
unsigned Map[Count]
Definition: AddressSpaces.h:45
const llvm::fltSemantics * FloatFormat
const llvm::fltSemantics * HalfFormat
virtual void getGCCAddlRegNames(const AddlRegName *&Addl, unsigned &NumAddl) const
virtual void getGCCRegNames(const char *const *&Names, unsigned &NumNames) const =0
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:43
StringRef getNormalizedGCCRegisterName(StringRef Name) const
Returns the "normalized" GCC register name.
Defines the clang::TargetInfo interface.
const llvm::fltSemantics * LongDoubleFormat
bool validateInputConstraint(ConstraintInfo *OutputConstraints, unsigned NumOutputs, ConstraintInfo &info) const
void setTiedOperand(unsigned N, ConstraintInfo &Output)
Indicate that this is an input operand that is tied to the specified output operand.
unsigned getShortAlign() const
Return the alignment of 'signed short' and 'unsigned short' for this target.
bool UseAddrSpaceMapMangling
Specify if mangling based on address space map should be used or not for language specific address sp...