Lines Matching defs:type
10 // This is the code that handles AST -> LLVM type lowering.
58 // Name the codegen type after the typedef name
59 // if there is no tag type name available
83 /// ConvertTypeForMem - Convert type T into a llvm::Type. This differs from
85 /// a type. For example, the scalar representation for _Bool is i1, but the
90 // If this is a non-bool type, don't map it.
100 /// isRecordLayoutComplete - Return true if the specified type is already
119 // If we have already checked this type (maybe the same type is used by-value
125 // If this type is already laid out, converting it is a noop.
128 // If this type is currently being laid out, we can't recursively compile it.
132 // If this type would require laying out bases that are currently being laid
144 // If this type would require laying out members that are currently being laid
155 /// isSafeToConvert - Return true if it is safe to convert this field type,
190 /// isFuncTypeArgumentConvertible - Return true if the specified type in a
191 /// function argument or result position can be converted to an IR type at this
193 /// we've temporarily deferred expanding the type because we're in a recursive
196 // If this isn't a tagged type, we can convert it!
209 // process of expanding, then we can't convert the function type. That's ok
211 // just convert it to a dummy type.
214 // opaque type for a struct that we know is defined.
219 /// Code to verify a given function type is complete, i.e. the return type
222 /// pended. If so, we don't want to ask the ABI lowering code to handle a type
223 /// that cannot be converted to an IR type.
237 /// replace the 'opaque' type we previously made for it if applicable.
243 // Only flush the cache if we've actually already converted this type.
255 // anonymous type, then go ahead and complete it now.
264 // If necessary, provide the full definition of a type only used with a
292 /// ConvertType - Convert the specified type to its LLVM form.
302 // See if type is already cached.
304 // If type is found in map then use it. Otherwise, convert type T.
326 // LLVM void type can only be used as the result of a function call. Just
332 // Note that we always return bool as i1 for use as a scalar type.
396 llvm_unreachable("Unexpected placeholder builtin type!");
401 llvm_unreachable("Unexpected undeduced auto type!");
431 // VLAs resolve to the innermost element type; this matches
440 // int X[] -> [0 x int], unless the element type is not sized. If it is
454 // Lower arrays of undefined struct type to arrays of i8 just to have a
455 // concrete type.
474 // First, check whether we can build the full function type. If the
475 // function type depends on an incomplete type (e.g. a struct or enum), we
476 // cannot lower the function type.
478 // This function's type depends on an incomplete tag type.
489 // Return a placeholder type.
506 // The function type can be built; call the appropriate routines to
557 // Protocol qualifications do not influence the LLVM type, we just return a
558 // pointer to the underlying interface type. We don't need to worry about
570 // Return a placeholder 'i32' type. This can be changed later when the
571 // type is defined (see UpdateCompletedType), but is likely to be the
611 assert(ResultType && "Didn't convert a type?");
617 bool CodeGenModule::isPaddedAtomicType(QualType type) {
618 return isPaddedAtomicType(type->castAs<AtomicType>());
621 bool CodeGenModule::isPaddedAtomicType(const AtomicType *type) {
622 return Context.getTypeSize(type) != Context.getTypeSize(type->getValueType());
625 /// ConvertRecordDeclType - Lay out a tagged decl type like struct or union.
628 // type connected to the decl.
640 // If this is still a forward declaration, or the LLVM type is already
646 // If converting this type would cause us to infinitely loop, don't do it!
652 // Okay, this is a definition of a type. Compile the implementation now.
696 // Compute the type information.
703 assert(Layout && "Unable to find record layout information for type");