[CIR][CIRGen] Move CIRGen types into clang::CIRGen (llvm#1082)

llvm/clangir#1025 explains why we want to move
the CIR dialect from the `mlir::cir` to the `cir` namespace. To avoid
overloading the `cir` namespace too much afterwards, move all symbols
whose equivalents live inside the `clang::CodeGen` namespace to a new
`clang::CIRGen` namespace, so that we match the original CodeGen's
structure more closely.

There's some symbols that live under `clang/include/clang/CIR` whose
equivalents live in `clang/lib/CodeGen` and are in the `clang::CodeGen`
namespace. We have these symbols in a common location since they're also
used by lowering, so I've also left them in the `cir` namespace. Those
symbols are:
- AArch64ABIKind
- ABIArgInfo
- FnInfoOpts
- TypeEvaluationKind
- X86AVXABILevel

This is a pretty large PR out of necessity. To make it slightly more
reviewable, I've split it out into three commits (which will be squashed
together when the PR lands):
- The first commit manually switches places to the `clang::CIRGen`
  namespace. This has to be manual because we only want to move things
  selectively.
- The second commit adjusts namespace prefixes to make builds work. I
  ran https://gist.github.com/smeenai/f4dd441fb61c53e835c4e6057f8c322f
  to make this change. The script is idempotent, and I added
  substitutions one at a time and reviewed each one afterwards (using
  `git diff --color-words=.`) to ensure only intended changes were being
  made.
- The third commit runs `git clang-format`.

Because I went one-by-one with all my substitutions and checked each one
afterwards, I'm pretty confident in the validity of all the changes
(despite the size of the PR).

Author: smeenai

clang/include/clang/CIR/CIRGenerator.h

@@ -34,12 +34,14 @@ namespace clang {
 class ASTContext;
 class DeclGroupRef;
 class FunctionDecl;
-} // namespace clang
 
-namespace cir {
+namespace CIRGen {
 class CIRGenModule;
 class CIRGenTypes;
+} // namespace CIRGen
+} // namespace clang
 
+namespace cir {
 class CIRGenerator : public clang::ASTConsumer {
   virtual void anchor();
   clang::DiagnosticsEngine &Diags;
@@ -70,7 +72,7 @@ class CIRGenerator : public clang::ASTConsumer {
 
 protected:
   std::unique_ptr<mlir::MLIRContext> mlirCtx;
-  std::unique_ptr<CIRGenModule> CGM;
+  std::unique_ptr<clang::CIRGen::CIRGenModule> CGM;
 
 private:
   llvm::SmallVector<clang::FunctionDecl *, 8> DeferredInlineMemberFuncDefs;

clang/lib/CIR/CodeGen/CIRAsm.cpp

@@ -699,7 +699,7 @@ mlir::LogicalResult CIRGenFunction::emitAsmStmt(const AsmStmt &S) {
       }
 
       // Update largest vector width for any vector types.
-      assert(!MissingFeatures::asmVectorType());
+      assert(!cir::MissingFeatures::asmVectorType());
     } else {
       Address DestAddr = Dest.getAddress();
 
@@ -735,7 +735,7 @@ mlir::LogicalResult CIRGenFunction::emitAsmStmt(const AsmStmt &S) {
         Arg = builder.createBitcast(Arg, AdjTy);
 
       // Update largest vector width for any vector types.
-      assert(!MissingFeatures::asmVectorType());
+      assert(!cir::MissingFeatures::asmVectorType());
 
       // Only tie earlyclobber physregs.
       if (Info.allowsRegister() && (GCCReg.empty() || Info.earlyClobber()))
@@ -752,7 +752,7 @@ mlir::LogicalResult CIRGenFunction::emitAsmStmt(const AsmStmt &S) {
   // If this is a Microsoft-style asm blob, store the return registers (EAX:EDX)
   // to the return value slot. Only do this when returning in registers.
   if (isa<MSAsmStmt>(&S)) {
-    const ABIArgInfo &RetAI = CurFnInfo->getReturnInfo();
+    const cir::ABIArgInfo &RetAI = CurFnInfo->getReturnInfo();
     if (RetAI.isDirect() || RetAI.isExtend()) {
       // Make a fake lvalue for the return value slot.
       LValue ReturnSlot = makeAddrLValue(ReturnValue, FnRetTy);
@@ -824,7 +824,7 @@ mlir::LogicalResult CIRGenFunction::emitAsmStmt(const AsmStmt &S) {
           << InputExpr->getType() << InputConstraint;
 
     // Update largest vector width for any vector types.
-    assert(!MissingFeatures::asmVectorType());
+    assert(!cir::MissingFeatures::asmVectorType());
 
     ArgTypes.push_back(Arg.getType());
     ArgElemTypes.push_back(ArgElemType);

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -43,14 +43,14 @@
 #include <string>
 #include <utility>
 
-namespace cir {
+namespace clang::CIRGen {
 
 class CIRGenFunction;
 
-class CIRGenBuilderTy : public CIRBaseBuilderTy {
+class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
   const CIRGenTypeCache &typeCache;
   bool IsFPConstrained = false;
-  fp::ExceptionBehavior DefaultConstrainedExcept = fp::ebStrict;
+  cir::fp::ExceptionBehavior DefaultConstrainedExcept = cir::fp::ebStrict;
   llvm::RoundingMode DefaultConstrainedRounding = llvm::RoundingMode::Dynamic;
 
   llvm::StringMap<unsigned> GlobalsVersioning;
@@ -96,10 +96,10 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
   }
 
   /// Set the exception handling to be used with constrained floating point
-  void setDefaultConstrainedExcept(fp::ExceptionBehavior NewExcept) {
+  void setDefaultConstrainedExcept(cir::fp::ExceptionBehavior NewExcept) {
 #ifndef NDEBUG
     std::optional<llvm::StringRef> ExceptStr =
-        convertExceptionBehaviorToStr(NewExcept);
+        cir::convertExceptionBehaviorToStr(NewExcept);
     assert(ExceptStr && "Garbage strict exception behavior!");
 #endif
     DefaultConstrainedExcept = NewExcept;
@@ -109,14 +109,14 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
   void setDefaultConstrainedRounding(llvm::RoundingMode NewRounding) {
 #ifndef NDEBUG
     std::optional<llvm::StringRef> RoundingStr =
-        convertRoundingModeToStr(NewRounding);
+        cir::convertRoundingModeToStr(NewRounding);
     assert(RoundingStr && "Garbage strict rounding mode!");
 #endif
     DefaultConstrainedRounding = NewRounding;
   }
 
   /// Get the exception handling used with constrained floating point
-  fp::ExceptionBehavior getDefaultConstrainedExcept() {
+  cir::fp::ExceptionBehavior getDefaultConstrainedExcept() {
     return DefaultConstrainedExcept;
   }
 
@@ -422,7 +422,7 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
     // FIXME: replay LLVM codegen for now, perhaps add a vtable ptr special
     // type so it's a bit more clear and C++ idiomatic.
     auto fnTy = mlir::cir::FuncType::get({}, getUInt32Ty(), isVarArg);
-    assert(!MissingFeatures::isVarArg());
+    assert(!cir::MissingFeatures::isVarArg());
     return getPointerTo(getPointerTo(fnTy));
   }
 
@@ -657,30 +657,30 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
   }
 
   mlir::Value createFSub(mlir::Value lhs, mlir::Value rhs) {
-    assert(!MissingFeatures::metaDataNode());
+    assert(!cir::MissingFeatures::metaDataNode());
     if (IsFPConstrained)
       llvm_unreachable("Constrained FP NYI");
 
-    assert(!MissingFeatures::foldBinOpFMF());
+    assert(!cir::MissingFeatures::foldBinOpFMF());
     return create<mlir::cir::BinOp>(lhs.getLoc(), mlir::cir::BinOpKind::Sub,
                                     lhs, rhs);
   }
 
   mlir::Value createFAdd(mlir::Value lhs, mlir::Value rhs) {
-    assert(!MissingFeatures::metaDataNode());
+    assert(!cir::MissingFeatures::metaDataNode());
     if (IsFPConstrained)
       llvm_unreachable("Constrained FP NYI");
 
-    assert(!MissingFeatures::foldBinOpFMF());
+    assert(!cir::MissingFeatures::foldBinOpFMF());
     return create<mlir::cir::BinOp>(lhs.getLoc(), mlir::cir::BinOpKind::Add,
                                     lhs, rhs);
   }
   mlir::Value createFMul(mlir::Value lhs, mlir::Value rhs) {
-    assert(!MissingFeatures::metaDataNode());
+    assert(!cir::MissingFeatures::metaDataNode());
     if (IsFPConstrained)
       llvm_unreachable("Constrained FP NYI");
 
-    assert(!MissingFeatures::foldBinOpFMF());
+    assert(!cir::MissingFeatures::foldBinOpFMF());
     return create<mlir::cir::BinOp>(lhs.getLoc(), mlir::cir::BinOpKind::Mul,
                                     lhs, rhs);
   }
@@ -697,16 +697,16 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
   mlir::Value createDynCastToVoid(mlir::Location loc, mlir::Value src,
                                   bool vtableUseRelativeLayout) {
     // TODO(cir): consider address space here.
-    assert(!MissingFeatures::addressSpace());
+    assert(!cir::MissingFeatures::addressSpace());
     auto destTy = getVoidPtrTy();
     return create<mlir::cir::DynamicCastOp>(
         loc, destTy, mlir::cir::DynamicCastKind::ptr, src,
         mlir::cir::DynamicCastInfoAttr{}, vtableUseRelativeLayout);
   }
 
-  cir::Address createBaseClassAddr(mlir::Location loc, cir::Address addr,
-                                   mlir::Type destType, unsigned offset,
-                                   bool assumeNotNull) {
+  Address createBaseClassAddr(mlir::Location loc, Address addr,
+                              mlir::Type destType, unsigned offset,
+                              bool assumeNotNull) {
     if (destType == addr.getElementType())
       return addr;
 
@@ -716,9 +716,9 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
     return Address(baseAddr, ptrTy, addr.getAlignment());
   }
 
-  cir::Address createDerivedClassAddr(mlir::Location loc, cir::Address addr,
-                                      mlir::Type destType, unsigned offset,
-                                      bool assumeNotNull) {
+  Address createDerivedClassAddr(mlir::Location loc, Address addr,
+                                 mlir::Type destType, unsigned offset,
+                                 bool assumeNotNull) {
     if (destType == addr.getElementType())
       return addr;
 
@@ -833,8 +833,8 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
 
   /// Cast the element type of the given address to a different type,
   /// preserving information like the alignment.
-  cir::Address createElementBitCast(mlir::Location loc, cir::Address addr,
-                                    mlir::Type destType) {
+  Address createElementBitCast(mlir::Location loc, Address addr,
+                               mlir::Type destType) {
     if (destType == addr.getElementType())
       return addr;
 
@@ -869,7 +869,7 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
   mlir::Value createAlignedLoad(mlir::Location loc, mlir::Type ty,
                                 mlir::Value ptr, llvm::MaybeAlign align) {
     // TODO: make sure callsites shouldn't be really passing volatile.
-    assert(!MissingFeatures::volatileLoadOrStore());
+    assert(!cir::MissingFeatures::volatileLoadOrStore());
     return createAlignedLoad(loc, ty, ptr, align, /*isVolatile=*/false);
   }
 
@@ -942,7 +942,7 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
   // but currently some parts of Clang AST, which we don't want to touch just
   // yet, return them.
   void computeGlobalViewIndicesFromFlatOffset(
-      int64_t Offset, mlir::Type Ty, CIRDataLayout Layout,
+      int64_t Offset, mlir::Type Ty, cir::CIRDataLayout Layout,
       llvm::SmallVectorImpl<int64_t> &Indices) {
     if (!Offset)
       return;
@@ -1046,7 +1046,7 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
         mlir::cast<mlir::cir::DataMemberType>(memberPtr.getType());
 
     // TODO(cir): consider address space.
-    assert(!MissingFeatures::addressSpace());
+    assert(!cir::MissingFeatures::addressSpace());
     auto resultTy = getPointerTo(memberPtrTy.getMemberTy());
 
     return create<mlir::cir::GetRuntimeMemberOp>(loc, resultTy, objectPtr,
@@ -1067,5 +1067,5 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
                                    mlir::Type eltTy);
 };
 
-} // namespace cir
+} // namespace clang::CIRGen
 #endif

clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp

@@ -65,7 +65,7 @@ static mlir::Value tryUseTestFPKind(CIRGenFunction &CGF, unsigned BuiltinID,
 static mlir::Value tryUseTestFPKind(CIRGenFunction &CGF, unsigned BuiltinID,
                                     mlir::Value V) {
   if (CGF.getBuilder().getIsFPConstrained() &&
-      CGF.getBuilder().getDefaultConstrainedExcept() != fp::ebIgnore) {
+      CGF.getBuilder().getDefaultConstrainedExcept() != cir::fp::ebIgnore) {
     if (mlir::Value Result = CGF.getTargetHooks().testFPKind(
             V, BuiltinID, CGF.getBuilder(), CGF.CGM))
       return Result;
@@ -2507,7 +2507,7 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
 
   case Builtin::BI__builtin_unpredictable: {
     if (CGM.getCodeGenOpts().OptimizationLevel != 0)
-      assert(!MissingFeatures::insertBuiltinUnpredictable());
+      assert(!cir::MissingFeatures::insertBuiltinUnpredictable());
     return RValue::get(buildScalarExpr(E->getArg(0)));
   }
 
@@ -3266,7 +3266,7 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
     // default (e.g. in C / C++ auto vars are in the generic address space). At
     // the AST level this is handled within CreateTempAlloca et al., but for the
     // builtin / dynamic alloca we have to handle it here.
-    assert(!MissingFeatures::addressSpace());
+    assert(!cir::MissingFeatures::addressSpace());
     auto AAS = getCIRAllocaAddressSpace();
     auto EAS = builder.getAddrSpaceAttr(
         E->getType()->getPointeeType().getAddressSpace());

clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp

@@ -3291,13 +3291,13 @@ mlir::Value buildNeonCall(CIRGenBuilderTy &builder,
                           unsigned shift = 0, bool rightshift = false) {
   // TODO: Consider removing the following unreachable when we have
   // buildConstrainedFPCall feature implemented
-  assert(!MissingFeatures::buildConstrainedFPCall());
+  assert(!cir::MissingFeatures::buildConstrainedFPCall());
   if (isConstrainedFPIntrinsic)
     llvm_unreachable("isConstrainedFPIntrinsic NYI");
 
   for (unsigned j = 0; j < argTypes.size(); ++j) {
     if (isConstrainedFPIntrinsic) {
-      assert(!MissingFeatures::buildConstrainedFPCall());
+      assert(!cir::MissingFeatures::buildConstrainedFPCall());
     }
     if (shift > 0 && shift == j) {
       args[j] = buildNeonShiftVector(
@@ -3308,7 +3308,7 @@ mlir::Value buildNeonCall(CIRGenBuilderTy &builder,
     }
   }
   if (isConstrainedFPIntrinsic) {
-    assert(!MissingFeatures::buildConstrainedFPCall());
+    assert(!cir::MissingFeatures::buildConstrainedFPCall());
     return nullptr;
   }
   return builder
@@ -3345,8 +3345,8 @@ buildCommonNeonCallPattern0(CIRGenFunction &cgf, llvm::StringRef intrincsName,
 mlir::Value CIRGenFunction::buildCommonNeonBuiltinExpr(
     unsigned builtinID, unsigned llvmIntrinsic, unsigned altLLVMIntrinsic,
     const char *nameHint, unsigned modifier, const CallExpr *e,
-    llvm::SmallVectorImpl<mlir::Value> &ops, cir::Address ptrOp0,
-    cir::Address ptrOp1, llvm::Triple::ArchType arch) {
+    llvm::SmallVectorImpl<mlir::Value> &ops, Address ptrOp0, Address ptrOp1,
+    llvm::Triple::ArchType arch) {
   // Get the last argument, which specifies the vector type.
   const clang::Expr *arg = e->getArg(e->getNumArgs() - 1);
   std::optional<llvm::APSInt> neonTypeConst =

clang/lib/CIR/CodeGen/CIRGenCall.cpp

@@ -1351,7 +1351,7 @@ CIRGenTypes::arrangeFreeFunctionType(CanQual<FunctionNoProtoType> FTNP) {
   // When translating an unprototyped function type, always use a
   // variadic type.
   return arrangeCIRFunctionInfo(FTNP->getReturnType().getUnqualifiedType(),
-                                FnInfoOpts::None, std::nullopt,
+                                cir::FnInfoOpts::None, std::nullopt,
                                 FTNP->getExtInfo(), {}, RequiredArgs(0));
 }