C++ 的 sizeof 是怎麼實現的？

case UETT_VecStep: {
QualType Ty = E-&>getTypeOfArgument();

if (Ty-&>isVectorType()) {
unsigned n = Ty-&>castAs&()-&>getNumElements();

// The vec_step built-in functions that take a 3-component
// vector return 4. (OpenCL 1.1 spec 6.11.12)
if (n == 3)
n = 4;

return Success(n, E);
} else
return Success(1, E);
}

case UETT_SizeOf: {
QualType SrcTy = E-&>getTypeOfArgument();
// C++ [expr.sizeof]p2: "When applied to a reference or a reference type,
// the result is the size of the referenced type."
if (const ReferenceType *Ref = SrcTy-&>getAs&())
SrcTy = Ref-&>getPointeeType();

CharUnits Sizeof;
if (!HandleSizeof(Info, E-&>getExprLoc(), SrcTy, Sizeof))
return false;
return Success(Sizeof, E);
}
}

if (!Type-&>isConstantSizeType()) {
// sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
// FIXME: Better diagnostic.
Info.Diag(Loc);
return false;
}

case Type::FunctionNoProto:
case Type::FunctionProto:
// GCC extension: alignof(function) = 32 bits
Width = 0;
Align = 32;
break;

case Type::IncompleteArray:
case Type::VariableArray:
Width = 0;
Align = getTypeAlign(cast&(T)-&>getElementType());
break;

case Type::ConstantArray: {
const ConstantArrayType *CAT = cast&(T);

TypeInfo EltInfo = getTypeInfo(CAT-&>getElementType());
uint64_t Size = CAT-&>getSize().getZExtValue();
assert((Size == 0 || EltInfo.Width &<= (uint64_t)(-1) / Size) "Overflow in array type bit size evaluation"); Width = EltInfo.Width * Size; Align = EltInfo.Align; if (!getTargetInfo().getCXXABI().isMicrosoft() || getTargetInfo().getPointerWidth(0) == 64) Width = llvm::RoundUpToAlignment(Width, Align); break; } case Type::ExtVector: case Type::Vector: { const VectorType *VT = cast&(T);
TypeInfo EltInfo = getTypeInfo(VT-&>getElementType());
Width = EltInfo.Width * VT-&>getNumElements();
Align = Width;
// If the alignment is not a power of 2, round up to the next power of 2.
// This happens for non-power-of-2 length vectors.
if (Align (Align-1)) {
Align = llvm::NextPowerOf2(Align);
Width = llvm::RoundUpToAlignment(Width, Align);
}
// Adjust the alignment based on the target max.
uint64_t TargetVectorAlign = Target-&>getMaxVectorAlign();
if (TargetVectorAlign TargetVectorAlign &< Align) Align = TargetVectorAlign; break; } case Type::Builtin: switch (cast&(T)-&>getKind()) {
default: llvm_unreachable("Unknown builtin type!");
case BuiltinType::Void:
// GCC extension: alignof(void) = 8 bits.
Width = 0;
Align = 8;
break;

case BuiltinType::Bool:
Width = Target-&>getBoolWidth();
Align = Target-&>getBoolAlign();
break;
case BuiltinType::Char_S:
case BuiltinType::Char_U:
case BuiltinType::UChar:
case BuiltinType::SChar:
Width = Target-&>getCharWidth();
Align = Target-&>getCharAlign();
break;
case BuiltinType::WChar_S:
case BuiltinType::WChar_U:
Width = Target-&>getWCharWidth();
Align = Target-&>getWCharAlign();
break;
case BuiltinType::Char16:
Width = Target-&>getChar16Width();
Align = Target-&>getChar16Align();
break;
case BuiltinType::Char32:
Width = Target-&>getChar32Width();
Align = Target-&>getChar32Align();
break;
case BuiltinType::UShort:
case BuiltinType::Short:
Width = Target-&>getShortWidth();
Align = Target-&>getShortAlign();
break;
case BuiltinType::UInt:
case BuiltinType::Int:
Width = Target-&>getIntWidth();
Align = Target-&>getIntAlign();
break;
case BuiltinType::ULong:
case BuiltinType::Long:
Width = Target-&>getLongWidth();
Align = Target-&>getLongAlign();
break;
case BuiltinType::ULongLong:
case BuiltinType::LongLong:
Width = Target-&>getLongLongWidth();
Align = Target-&>getLongLongAlign();
break;
case BuiltinType::Int128:
case BuiltinType::UInt128:
Width = 128;
Align = 128; // int128_t is 128-bit aligned on all targets.
break;
case BuiltinType::Half:
Width = Target-&>getHalfWidth();
Align = Target-&>getHalfAlign();
break;
case BuiltinType::Float:
Width = Target-&>getFloatWidth();
Align = Target-&>getFloatAlign();
break;
case BuiltinType::Double:
Width = Target-&>getDoubleWidth();
Align = Target-&>getDoubleAlign();
break;
case BuiltinType::LongDouble:
Width = Target-&>getLongDoubleWidth();
Align = Target-&>getLongDoubleAlign();
break;
case BuiltinType::NullPtr:
Width = Target-&>getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t)
Align = Target-&>getPointerAlign(0); // == sizeof(void*)
break;
case BuiltinType::ObjCId:
case BuiltinType::ObjCClass:
case BuiltinType::ObjCSel:
Width = Target-&>getPointerWidth(0);
Align = Target-&>getPointerAlign(0);
break;
case BuiltinType::OCLSampler:
// Samplers are modeled as integers.
Width = Target-&>getIntWidth();
Align = Target-&>getIntAlign();
break;
case BuiltinType::OCLEvent:
case BuiltinType::OCLImage1d:
case BuiltinType::OCLImage1dArray:
case BuiltinType::OCLImage1dBuffer:
case BuiltinType::OCLImage2d:
case BuiltinType::OCLImage2dArray:
case BuiltinType::OCLImage3d:
// Currently these types are pointers to opaque types.
Width = Target-&>getPointerWidth(0);
Align = Target-&>getPointerAlign(0);
break;
}
break;
case Type::ObjCObjectPointer:
Width = Target-&>getPointerWidth(0);
Align = Target-&>getPointerAlign(0);
break;
case Type::BlockPointer: {
unsigned AS = getTargetAddressSpace(
cast&(T)-&>getPointeeType());
Width = Target-&>getPointerWidth(AS);
Align = Target-&>getPointerAlign(AS);
break;
}
case Type::LValueReference:
case Type::RValueReference: {
// alignof and sizeof should never enter this code path here, so we go
// the pointer route.
unsigned AS = getTargetAddressSpace(
cast&(T)-&>getPointeeType());
Width = Target-&>getPointerWidth(AS);
Align = Target-&>getPointerAlign(AS);
break;
}
case Type::Pointer: {
unsigned AS = getTargetAddressSpace(cast&(T)-&>getPointeeType());
Width = Target-&>getPointerWidth(AS);
Align = Target-&>getPointerAlign(AS);
break;
}
case Type::MemberPointer: {
const MemberPointerType *MPT = cast&(T);
std::tie(Width, Align) = ABI-&>getMemberPointerWidthAndAlign(MPT);
break;
}
case Type::Complex: {
// Complex types have the same alignment as their elements, but twice the
// size.
TypeInfo EltInfo = getTypeInfo(cast&(T)-&>getElementType());
Width = EltInfo.Width * 2;
Align = EltInfo.Align;
break;
}
case Type::ObjCObject:
return getTypeInfo(cast&(T)-&>getBaseType().getTypePtr());
case Type::Adjusted:
case Type::Decayed:
return getTypeInfo(cast&(T)-&>getAdjustedType().getTypePtr());
case Type::ObjCInterface: {
const ObjCInterfaceType *ObjCI = cast&(T);
const ASTRecordLayout Layout = getASTObjCInterfaceLayout(ObjCI-&>getDecl());
Width = toBits(Layout.getSize());
Align = toBits(Layout.getAlignment());
break;
}
case Type::Record:
case Type::Enum: {
const TagType *TT = cast&(T);

if (TT-&>getDecl()-&>isInvalidDecl()) {
Width = 8;
Align = 8;
break;
}

if (const EnumType *ET = dyn_cast&(TT)) {
const EnumDecl *ED = ET-&>getDecl();
TypeInfo Info =
getTypeInfo(ED-&>getIntegerType()-&>getUnqualifiedDesugaredType());
if (unsigned AttrAlign = ED-&>getMaxAlignment()) {
Info.Align = AttrAlign;
Info.AlignIsRequired = true;
}
return Info;
}

const RecordType *RT = cast&(TT);
const RecordDecl *RD = RT-&>getDecl();
const ASTRecordLayout Layout = getASTRecordLayout(RD);
Width = toBits(Layout.getSize());
Align = toBits(Layout.getAlignment());
AlignIsRequired = RD-&>hasAttr&();
break;
}

case Type::SubstTemplateTypeParm:
return getTypeInfo(cast&(T)-&>
getReplacementType().getTypePtr());

case Type::Auto: {
const AutoType *A = cast&(T);
assert(!A-&>getDeducedType().isNull()
"cannot request the size of an undeduced or dependent auto type");
return getTypeInfo(A-&>getDeducedType().getTypePtr());
}

case Type::Paren:
return getTypeInfo(cast&(T)-&>getInnerType().getTypePtr());

case Type::Typedef: {
const TypedefNameDecl *Typedef = cast&(T)-&>getDecl();
TypeInfo Info = getTypeInfo(Typedef-&>getUnderlyingType().getTypePtr());
// If the typedef has an aligned attribute on it, it overrides any computed
// alignment we have. This violates the GCC documentation (which says that
// attribute(aligned) can only round up) but matches its implementation.
if (unsigned AttrAlign = Typedef-&>getMaxAlignment()) {
Align = AttrAlign;
AlignIsRequired = true;
} else {
Align = Info.Align;
AlignIsRequired = Info.AlignIsRequired;
}
Width = Info.Width;
break;
}

case Type::Elaborated:
return getTypeInfo(cast&(T)-&>getNamedType().getTypePtr());

case Type::Attributed:
return getTypeInfo(
cast&(T)-&>getEquivalentType().getTypePtr());

case Type::Atomic: {
// Start with the base type information.
TypeInfo Info = getTypeInfo(cast&(T)-&>getValueType());
Width = Info.Width;
Align = Info.Align;

// If the size of the type doesn"t exceed the platform"s max
// atomic promotion width, make the size and alignment more
// favorable to atomic operations:
if (Width != 0 Width &<= Target-&>getMaxAtomicPromoteWidth()) {
// Round the size up to a power of 2.
if (!llvm::isPowerOf2_64(Width))
Width = llvm::NextPowerOf2(Width);

// Set the alignment equal to the size.
Align = static_cast&(Width);
}
}