Refactor sizeof handling to use constant folding logic for constant

sizeof expressions.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@62941 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/AST/ExprConstant.cpp b/lib/AST/ExprConstant.cpp
index 49cc3201db974af205ded708e5f7cfdc0a173e22..4c242059b52859d6765590041b548fc724430c2e 100644 (file)
--- a/lib/AST/ExprConstant.cpp
+++ b/lib/AST/ExprConstant.cpp
@@ -916,17 +916,22 @@ bool IntExprEvaluator::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) {
   // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
   if (!SrcTy->isConstantSizeType())
     return false;
-
-  // sizeof (objc class) ?
-  if (SrcTy->isObjCInterfaceType())
-    return false;
   
   // GCC extension: sizeof(function) = 1.
   if (SrcTy->isFunctionType()) {
     Result = 1;
     return true;
   }
-  
+
+  if (SrcTy->isObjCInterfaceType()) {
+    // Slightly unusual case: the size of an ObjC interface type is the
+    // size of the class.  This code intentionally falls through to the normal
+    // case.
+    ObjCInterfaceDecl *OI = SrcTy->getAsObjCInterfaceType()->getDecl();
+    RecordDecl *RD = const_cast<RecordDecl*>(Info.Ctx.addRecordToClass(OI));
+    SrcTy = Info.Ctx.getTagDeclType(static_cast<TagDecl*>(RD));
+  }
+
   // Get information about the size.
   unsigned CharSize = Info.Ctx.Target.getCharWidth();
   Result = Info.Ctx.getTypeSize(SrcTy) / CharSize;

diff --git a/lib/CodeGen/CGExprScalar.cpp b/lib/CodeGen/CGExprScalar.cpp
index b1150cb2d10bbe081cd17861384b1fc848afac5a..766721e96b44f2ddbf033e1b15e4f3d199f5677e 100644 (file)
--- a/lib/CodeGen/CGExprScalar.cpp
+++ b/lib/CodeGen/CGExprScalar.cpp
@@ -673,45 +673,23 @@ Value *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) {
 /// argument of the sizeof expression as an integer.
 Value *
 ScalarExprEmitter::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) {
-  // Handle alignof with the constant folding logic.  alignof always produces a
-  // constant.
-  if (!E->isSizeOf()) {
-    Expr::EvalResult Result;
-    E->Evaluate(Result, CGF.getContext());
-    return llvm::ConstantInt::get(Result.Val.getInt());
-  }
-  
-  QualType RetType = E->getType();
-  assert(RetType->isIntegerType() && "Result type must be an integer!");
-  uint32_t ResultWidth = 
-    static_cast<uint32_t>(CGF.getContext().getTypeSize(RetType));
-  
-  // sizeof(void) and sizeof(function) = 1 as a strange gcc extension.
   QualType TypeToSize = E->getTypeOfArgument();
-  if (TypeToSize->isVoidType() || TypeToSize->isFunctionType())
-    return llvm::ConstantInt::get(llvm::APInt(ResultWidth, 1));
-  
-  if (const VariableArrayType *VAT = 
-        CGF.getContext().getAsVariableArrayType(TypeToSize)) {
-    if (E->isArgumentType()) {
-      // sizeof(type) - make sure to emit the VLA size.
-      CGF.EmitVLASize(TypeToSize);
+  if (E->isSizeOf()) {
+    if (const VariableArrayType *VAT = 
+          CGF.getContext().getAsVariableArrayType(TypeToSize)) {
+      if (E->isArgumentType()) {
+        // sizeof(type) - make sure to emit the VLA size.
+        CGF.EmitVLASize(TypeToSize);
+      }
+      return CGF.GetVLASize(VAT);
     }
-    return CGF.GetVLASize(VAT);
   }
-  
-  if (TypeToSize->isObjCInterfaceType()) {
-    ObjCInterfaceDecl *OI = TypeToSize->getAsObjCInterfaceType()->getDecl();
-    RecordDecl *RD = const_cast<RecordDecl*>(
-                                        CGF.getContext().addRecordToClass(OI));
-    TypeToSize =  CGF.getContext().getTagDeclType(static_cast<TagDecl*>(RD));
-  }  
-  
-  uint64_t Val = CGF.getContext().getTypeSize(TypeToSize);
-  // Return size in bytes, not bits.
-  Val /= CGF.getContext().Target.getCharWidth();
-  
-  return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
+
+  // If this isn't sizeof(vla), the result must be constant; use the
+  // constant folding logic so we don't have to duplicate it here.
+  Expr::EvalResult Result;
+  E->Evaluate(Result, CGF.getContext());
+  return llvm::ConstantInt::get(Result.Val.getInt());
 }
 
 Value *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) {