Lines Matching defs:AS
764 // (as we're expected to) constrain that by the alignment of the type.
948 unsigned AS = getTargetAddressSpace(
950 Width = Target->getPointerWidth(AS);
951 Align = Target->getPointerAlign(AS);
958 unsigned AS = getTargetAddressSpace(
960 Width = Target->getPointerWidth(AS);
961 Align = Target->getPointerAlign(AS);
965 unsigned AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType());
966 Width = Target->getPointerWidth(AS);
967 Align = Target->getPointerAlign(AS);
979 // Complex types have the same alignment as their elements, but twice the
1086 // FIXME: We could potentially promote the width here as well...
1715 // preserve structure except as noted by comments.
1877 // then just use that as our result.
2002 // We already have a canonical version of this array type; use it as
2808 // typeof(expr) type. Use that as our canonical type.
2845 // as the type of the entity named by e.
2855 // (parentheses around e are ignored), decltype(e) is defined as the
2863 // defined as T&, otherwise decltype(e) is defined as T.
2891 // decltype type. Use that as our canonical type.
3002 /// Used when in C++, as a GCC extension.
3009 /// Used when in C++, as a GCC extension.
3317 // as the canonical nested-name-specifier. This is required to canonicalize
3329 // Do the same thing as above, but with dependent-named specializations.
3373 // sugar such as a typedef in the way. If we have type qualifiers on the type
3416 // A declaration of a parameter as "array of type" shall be
3424 // A declaration of a parameter as "function returning type"
3425 // shall be adjusted to "pointer to function returning type", as
3854 // void *__copy_helper; // as needed
3855 // void *__destroy_help // as needed
3937 // Make all integer and enum types at least as large as an int
3940 // Treat arrays as pointers, since that's how they're passed in.
4088 // Process argument qualifiers for user supplied arguments; such as,
4103 /// Property attributes are stored as a comma-delimited C string. The simple
4104 /// attributes readonly and bycopy are encoded as single characters. The
4106 /// encoded as single characters, followed by an identifier. Property types
4107 /// are also encoded as a parametrized attribute. The characters used to encode
4213 /// Another legacy compatibility encoding: 32-bit longs are encoded as
4283 // The NeXT runtime encodes bit fields as b followed by the number of bits.
4284 // The GNU runtime requires more information; bitfields are encoded as b,
4372 // char pointer types should be encoded as '*' unless it is a
4403 // Incomplete arrays are encoded as a pointer to the array element.
4417 //Variable length arrays are encoded as a regular array with 0 elements.
4438 // Anonymous structures print as '?'
4562 // We encode the underlying type which comes out as
4835 /// template name such as \c std::vector.
4858 /// template name such as \c MetaFun::template apply.
4892 /// template name such as \c MetaFun::template operator+.
4999 // (or pointers to them) be treated as though they were declared
5000 // as __strong.
5040 // Treat Neon vector types and most AltiVec vector types as if they are the
5274 /// arguments in block literals. When passed as arguments, passing 'A*' where
5355 /// one found. Note that this is O'2 algorithm. But it will be called as the
5525 /// mergeFunctionArgumentTypes - merge two types which appear as function
5530 // GNU extension: two types are compatible if they appear as a function
5680 // types and floats, which would be passed as a different
5775 // Same as above for arrays
6130 /// types. This allows "v2i*" to be parsed as a pointer to a v2i instead of
