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