- Revert ASTContecxt refactor

- return nullptr -> {}
- Add braces after else

Author: mmha

clang/include/clang/AST/ASTContext.h

@@ -2999,9 +2999,6 @@ class ASTContext : public RefCountedBase<ASTContext> {
   /// 6.3.1.1p2, assuming that \p PromotableType is a promotable integer type.
   QualType getPromotedIntegerType(QualType PromotableType) const;
 
-  /// If \p E is a widened promoted integer, get its base (unpromoted) type.
-  std::optional<QualType> getUnwidenedIntegerType(const Expr *E) const;
-
   /// Recurses in pointer/array types until it finds an Objective-C
   /// retainable type and returns its ownership.
   Qualifiers::ObjCLifetime getInnerObjCOwnership(QualType T) const;

clang/lib/AST/ASTContext.cpp

@@ -7998,22 +7998,6 @@ QualType ASTContext::getPromotedIntegerType(QualType Promotable) const {
   return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy;
 }
 
-/// getUnwidenedIntegerType - If \p E is a widened promoted integer, get its
-/// base (unpromoted) type.
-std::optional<QualType>
-ASTContext::getUnwidenedIntegerType(const Expr *E) const {
-  const Expr *Base = E->IgnoreImpCasts();
-  if (E == Base)
-    return std::nullopt;
-
-  QualType BaseTy = Base->getType();
-  if (!isPromotableIntegerType(BaseTy) ||
-      getTypeSize(BaseTy) >= getTypeSize(E->getType()))
-    return std::nullopt;
-
-  return BaseTy;
-}
-
 /// Recurses in pointer/array types until it finds an objc retainable
 /// type and returns its ownership.
 Qualifiers::ObjCLifetime ASTContext::getInnerObjCOwnership(QualType T) const {

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -89,12 +89,12 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
 
   mlir::Value emitPromotedValue(mlir::Value result, QualType promotionType) {
     cgf.cgm.errorNYI(result.getLoc(), "floating cast for promoted value");
-    return nullptr;
+    return {};
   }
 
   mlir::Value emitUnPromotedValue(mlir::Value result, QualType exprType) {
     cgf.cgm.errorNYI(result.getLoc(), "floating cast for unpromoted value");
-    return nullptr;
+    return {};
   }
 
   mlir::Value emitPromoted(const Expr *e, QualType promotionType);
@@ -867,10 +867,25 @@ mlir::Value CIRGenFunction::emitPromotedScalarExpr(const Expr *e,
   return e->getType()->isNullPtrType();
 }
 
+/// If \p e is a widened promoted integer, get its base (unpromoted) type.
+static std::optional<QualType>
+getUnwidenedIntegerType(const ASTContext &astContext, const Expr *e) {
+  const Expr *base = e->IgnoreImpCasts();
+  if (e == base)
+    return std::nullopt;
+
+  QualType baseTy = base->getType();
+  if (!astContext.isPromotableIntegerType(baseTy) ||
+      astContext.getTypeSize(baseTy) >= astContext.getTypeSize(e->getType()))
+    return std::nullopt;
+
+  return baseTy;
+}
+
 /// Check if \p e is a widened promoted integer.
 [[maybe_unused]] static bool isWidenedIntegerOp(const ASTContext &astContext,
                                                 const Expr *e) {
-  return astContext.getUnwidenedIntegerType(e).has_value();
+  return getUnwidenedIntegerType(astContext, e).has_value();
 }
 
 /// Check if we can skip the overflow check for \p Op.
@@ -892,12 +907,12 @@ mlir::Value CIRGenFunction::emitPromotedScalarExpr(const Expr *e,
   // Multiplication with promoted unsigned operands is a special case.
   const auto *bo = cast<BinaryOperator>(op.e);
   std::optional<QualType> optionalLHSTy =
-      astContext.getUnwidenedIntegerType(bo->getLHS());
+      getUnwidenedIntegerType(astContext, bo->getLHS());
   if (!optionalLHSTy)
     return false;
 
   std::optional<QualType> optionalRHSTy =
-      astContext.getUnwidenedIntegerType(bo->getRHS());
+      getUnwidenedIntegerType(astContext, bo->getRHS());
   if (!optionalRHSTy)
     return false;
 

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -1045,8 +1045,9 @@ mlir::LogicalResult CIRToLLVMBinOpLowering::matchAndRewrite(
       }
       rewriter.replaceOpWithNewOp<mlir::LLVM::AddOp>(op, llvmTy, lhs, rhs,
                                                      getIntOverflowFlag(op));
-    } else
+    } else {
       rewriter.replaceOpWithNewOp<mlir::LLVM::FAddOp>(op, lhs, rhs);
+    }
     break;
   case cir::BinOpKind::Sub:
     if (mlir::isa<mlir::IntegerType>(llvmEltTy)) {
@@ -1060,8 +1061,9 @@ mlir::LogicalResult CIRToLLVMBinOpLowering::matchAndRewrite(
       }
       rewriter.replaceOpWithNewOp<mlir::LLVM::SubOp>(op, llvmTy, lhs, rhs,
                                                      getIntOverflowFlag(op));
-    } else
+    } else {
       rewriter.replaceOpWithNewOp<mlir::LLVM::FSubOp>(op, lhs, rhs);
+    }
     break;
   case cir::BinOpKind::Mul:
     if (mlir::isa<mlir::IntegerType>(llvmEltTy))
@@ -1077,8 +1079,9 @@ mlir::LogicalResult CIRToLLVMBinOpLowering::matchAndRewrite(
         rewriter.replaceOpWithNewOp<mlir::LLVM::UDivOp>(op, lhs, rhs);
       else
         rewriter.replaceOpWithNewOp<mlir::LLVM::SDivOp>(op, lhs, rhs);
-    } else
+    } else {
       rewriter.replaceOpWithNewOp<mlir::LLVM::FDivOp>(op, lhs, rhs);
+    }
     break;
   case cir::BinOpKind::Rem:
     if (mlir::isa<mlir::IntegerType>(llvmEltTy)) {
@@ -1087,8 +1090,9 @@ mlir::LogicalResult CIRToLLVMBinOpLowering::matchAndRewrite(
         rewriter.replaceOpWithNewOp<mlir::LLVM::URemOp>(op, lhs, rhs);
       else
         rewriter.replaceOpWithNewOp<mlir::LLVM::SRemOp>(op, lhs, rhs);
-    } else
+    } else {
       rewriter.replaceOpWithNewOp<mlir::LLVM::FRemOp>(op, lhs, rhs);
+    }
     break;
   case cir::BinOpKind::And:
     rewriter.replaceOpWithNewOp<mlir::LLVM::AndOp>(op, lhs, rhs);
@@ -1251,8 +1255,8 @@ void ConvertCIRToLLVMPass::runOnOperation() {
                                             dl);
   patterns.add<
       // clang-format off
-               CIRToLLVMBrCondOpLowering,
                CIRToLLVMBinOpLowering,
+               CIRToLLVMBrCondOpLowering,
                CIRToLLVMBrOpLowering,
                CIRToLLVMFuncOpLowering,
                CIRToLLVMTrapOpLowering,

clang/lib/CodeGen/CGExprScalar.cpp

@@ -168,9 +168,24 @@ static bool MustVisitNullValue(const Expr *E) {
   return E->getType()->isNullPtrType();
 }
 
+/// If \p E is a widened promoted integer, get its base (unpromoted) type.
+static std::optional<QualType> getUnwidenedIntegerType(const ASTContext &Ctx,
+                                                       const Expr *E) {
+  const Expr *Base = E->IgnoreImpCasts();
+  if (E == Base)
+    return std::nullopt;
+
+  QualType BaseTy = Base->getType();
+  if (!Ctx.isPromotableIntegerType(BaseTy) ||
+      Ctx.getTypeSize(BaseTy) >= Ctx.getTypeSize(E->getType()))
+    return std::nullopt;
+
+  return BaseTy;
+}
+
 /// Check if \p E is a widened promoted integer.
 static bool IsWidenedIntegerOp(const ASTContext &Ctx, const Expr *E) {
-  return Ctx.getUnwidenedIntegerType(E).has_value();
+  return getUnwidenedIntegerType(Ctx, E).has_value();
 }
 
 /// Check if we can skip the overflow check for \p Op.
@@ -213,11 +228,11 @@ static bool CanElideOverflowCheck(const ASTContext &Ctx, const BinOpInfo &Op) {
   if (BO->hasExcludedOverflowPattern())
     return true;
 
-  auto OptionalLHSTy = Ctx.getUnwidenedIntegerType(BO->getLHS());
+  auto OptionalLHSTy = getUnwidenedIntegerType(Ctx, BO->getLHS());
   if (!OptionalLHSTy)
     return false;
 
-  auto OptionalRHSTy = Ctx.getUnwidenedIntegerType(BO->getRHS());
+  auto OptionalRHSTy = getUnwidenedIntegerType(Ctx, BO->getRHS());
   if (!OptionalRHSTy)
     return false;