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>
21 using namespace clang;
22
23 static const LangAS::Map DefaultAddrSpaceMap = { 0 };
24
25 // TargetInfo Constructor.
TargetInfo(const std::string & T)26 TargetInfo::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.
~TargetInfo()80 TargetInfo::~TargetInfo() {}
81
82 /// getTypeName - Return the user string for the specified integer type enum.
83 /// For example, SignedShort -> "short".
getTypeName(IntType T)84 const 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".
getTypeConstantSuffix(IntType T)100 const 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().
getTypeWidth(IntType T) const116 unsigned 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().
getTypeAlign(IntType T) const132 unsigned 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.
isTypeSigned(IntType T)148 bool 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.
setForcedLangOptions(LangOptions & Opts)167 void TargetInfo::setForcedLangOptions(LangOptions &Opts) {
168 if (Opts.NoBitFieldTypeAlign)
169 UseBitFieldTypeAlignment = false;
170 if (Opts.ShortWChar)
171 WCharType = UnsignedShort;
172 }
173
174 //===----------------------------------------------------------------------===//
175
176
removeGCCRegisterPrefix(llvm::StringRef Name)177 static llvm::StringRef removeGCCRegisterPrefix(llvm::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.
isValidClobber(llvm::StringRef Name) const187 bool TargetInfo::isValidClobber(llvm::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.
isValidGCCRegisterName(llvm::StringRef Name) const195 bool TargetInfo::isValidGCCRegisterName(llvm::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
251 llvm::StringRef
getNormalizedGCCRegisterName(llvm::StringRef Name) const252 TargetInfo::getNormalizedGCCRegisterName(llvm::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
validateOutputConstraint(ConstraintInfo & Info) const304 bool 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
resolveSymbolicName(const char * & Name,ConstraintInfo * OutputConstraints,unsigned NumOutputs,unsigned & Index) const359 bool 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
validateInputConstraint(ConstraintInfo * OutputConstraints,unsigned NumOutputs,ConstraintInfo & Info) const383 bool 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