[CIR] Centralize feature guarding (#649)

Moves all feature guarding static methods into a to a single header
file, centralizing the tracking of missing features in a common place
regardless of where it impacts the compilation pipeline. It also moves
the feature guarding logic into CIR's root include folder so that any
CIR library may use it.

Author: sitio-couto

clang/lib/CIR/CodeGen/UnimplementedFeatureGuarding.h renamed to clang/include/clang/CIR/MissingFeatures.h

@@ -1,4 +1,4 @@
-//===---- UnimplementedFeatureGuarding.h - Checks against NYI ---*- C++ -*-===//
+//===---- MissingFeatures.h - Checks for unimplemented features -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,16 +7,17 @@
 //===----------------------------------------------------------------------===//
 //
 // This file introduces some helper classes to guard against features that
-// CodeGen supports that we do not have and also do not have great ways to
+// CIR dialect supports that we do not have and also do not have great ways to
 // assert against.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_LIB_CIR_UFG
-#define LLVM_CLANG_LIB_CIR_UFG
+#ifndef CLANG_CIR_MISSINGFEATURES_H
+#define CLANG_CIR_MISSINGFEATURES_H
 
 namespace cir {
-struct UnimplementedFeature {
+
+struct MissingFeatures {
   // TODO(CIR): Implement the CIRGenFunction::buildTypeCheck method that handles
   // sanitizer related type check features
   static bool buildTypeCheck() { return false; }
@@ -169,12 +170,24 @@ struct UnimplementedFeature {
   static bool shouldInstrumentFunction() { return false; }
 
   // Inline assembly
-  static bool asm_goto() { return false; }
-  static bool asm_unwind_clobber() { return false; }
-  static bool asm_memory_effects() { return false; }
-  static bool asm_vector_type() { return false; }
-  static bool asm_llvm_assume() { return false; }
+  static bool asmGoto() { return false; }
+  static bool asmUnwindClobber() { return false; }
+  static bool asmMemoryEffects() { return false; }
+  static bool asmVectorType() { return false; }
+  static bool asmLLVMAssume() { return false; }
+
+  // C++ ABI support
+  static bool handleBigEndian() { return false; }
+  static bool handleAArch64Indirect() { return false; }
+  static bool classifyArgumentTypeForAArch64() { return false; }
+  static bool supportgetCoerceToTypeForAArch64() { return false; }
+  static bool supportTySizeQueryForAArch64() { return false; }
+  static bool supportTyAlignQueryForAArch64() { return false; }
+  static bool supportisHomogeneousAggregateQueryForAArch64() { return false; }
+  static bool supportisEndianQueryForAArch64() { return false; }
+  static bool supportisAggregateTypeForABIAArch64() { return false; }
 };
+
 } // namespace cir
 
-#endif
+#endif // CLANG_CIR_MISSINGFEATURES_H

clang/lib/CIR/CodeGen/CIRAsm.cpp

@@ -3,7 +3,7 @@
 
 #include "CIRGenFunction.h"
 #include "TargetInfo.h"
-#include "UnimplementedFeatureGuarding.h"
+#include "clang/CIR/MissingFeatures.h"
 
 using namespace cir;
 using namespace clang;
@@ -285,7 +285,7 @@ static void buildAsmStores(CIRGenFunction &CGF, const AsmStmt &S,
     mlir::Type TruncTy = ResultTruncRegTypes[i];
 
     if ((i < ResultRegIsFlagReg.size()) && ResultRegIsFlagReg[i]) {
-      assert(!UnimplementedFeature::asm_llvm_assume());
+      assert(!MissingFeatures::asmLLVMAssume());
     }
 
     // If the result type of the LLVM IR asm doesn't match the result type of
@@ -311,7 +311,7 @@ static void buildAsmStores(CIRGenFunction &CGF, const AsmStmt &S,
       } else if (isa<mlir::cir::IntType>(TruncTy)) {
         Tmp = Builder.createIntCast(Tmp, TruncTy);
       } else if (false /*TruncTy->isVectorTy()*/) {
-        assert(!UnimplementedFeature::asm_vector_type());
+        assert(!MissingFeatures::asmVectorType());
       }
     }
 
@@ -468,7 +468,7 @@ mlir::LogicalResult CIRGenFunction::buildAsmStmt(const AsmStmt &S) {
       }
 
       // Update largest vector width for any vector types.
-      assert(!UnimplementedFeature::asm_vector_type());
+      assert(!MissingFeatures::asmVectorType());
     } else {
       Address DestAddr = Dest.getAddress();
 
@@ -504,7 +504,7 @@ mlir::LogicalResult CIRGenFunction::buildAsmStmt(const AsmStmt &S) {
         Arg = builder.createBitcast(Arg, AdjTy);
 
       // Update largest vector width for any vector types.
-      assert(!UnimplementedFeature::asm_vector_type());
+      assert(!MissingFeatures::asmVectorType());
 
       // Only tie earlyclobber physregs.
       if (Info.allowsRegister() && (GCCReg.empty() || Info.earlyClobber()))
@@ -593,7 +593,7 @@ mlir::LogicalResult CIRGenFunction::buildAsmStmt(const AsmStmt &S) {
           << InputExpr->getType() << InputConstraint;
 
     // Update largest vector width for any vector types.
-    assert(!UnimplementedFeature::asm_vector_type());
+    assert(!MissingFeatures::asmVectorType());
 
     ArgTypes.push_back(Arg.getType());
     ArgElemTypes.push_back(ArgElemType);
@@ -636,11 +636,11 @@ mlir::LogicalResult CIRGenFunction::buildAsmStmt(const AsmStmt &S) {
       HasSideEffect, inferFlavor(CGM, S), mlir::ArrayAttr());
 
   if (false /*IsGCCAsmGoto*/) {
-    assert(!UnimplementedFeature::asm_goto());
+    assert(!MissingFeatures::asmGoto());
   } else if (HasUnwindClobber) {
-    assert(!UnimplementedFeature::asm_unwind_clobber());
+    assert(!MissingFeatures::asmUnwindClobber());
   } else {
-    assert(!UnimplementedFeature::asm_memory_effects());
+    assert(!MissingFeatures::asmMemoryEffects());
 
     mlir::Value result;
     if (IA.getNumResults())

clang/lib/CIR/CodeGen/CIRGenAtomic.cpp

@@ -16,14 +16,14 @@
 #include "CIRGenModule.h"
 #include "CIRGenOpenMPRuntime.h"
 #include "TargetInfo.h"
-#include "UnimplementedFeatureGuarding.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/CIR/Dialect/IR/CIRAttrs.h"
 #include "clang/CIR/Dialect/IR/CIRDataLayout.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
 #include "clang/CIR/Dialect/IR/CIROpsEnums.h"
 #include "clang/CIR/Dialect/IR/CIRTypes.h"
+#include "clang/CIR/MissingFeatures.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -440,7 +440,7 @@ static void buildAtomicOp(CIRGenFunction &CGF, AtomicExpr *E, Address Dest,
                           mlir::Value IsWeak, mlir::Value FailureOrder,
                           uint64_t Size, mlir::cir::MemOrder Order,
                           uint8_t Scope) {
-  assert(!UnimplementedFeature::syncScopeID());
+  assert(!MissingFeatures::syncScopeID());
   StringRef Op;
 
   auto &builder = CGF.getBuilder();
@@ -487,7 +487,7 @@ static void buildAtomicOp(CIRGenFunction &CGF, AtomicExpr *E, Address Dest,
   case AtomicExpr::AO__scoped_atomic_load: {
     auto *load = builder.createLoad(loc, Ptr).getDefiningOp();
     // FIXME(cir): add scope information.
-    assert(!UnimplementedFeature::syncScopeID());
+    assert(!MissingFeatures::syncScopeID());
     load->setAttr("mem_order", orderAttr);
     if (E->isVolatile())
       load->setAttr("is_volatile", mlir::UnitAttr::get(builder.getContext()));
@@ -512,7 +512,7 @@ static void buildAtomicOp(CIRGenFunction &CGF, AtomicExpr *E, Address Dest,
   case AtomicExpr::AO__scoped_atomic_store_n: {
     auto loadVal1 = builder.createLoad(loc, Val1);
     // FIXME(cir): add scope information.
-    assert(!UnimplementedFeature::syncScopeID());
+    assert(!MissingFeatures::syncScopeID());
     builder.createStore(loc, loadVal1, Ptr, E->isVolatile(),
                         /*alignment=*/mlir::IntegerAttr{}, orderAttr);
     return;
@@ -685,15 +685,15 @@ static void buildAtomicOp(CIRGenFunction &CGF, AtomicExpr *Expr, Address Dest,
   // LLVM atomic instructions always have synch scope. If clang atomic
   // expression has no scope operand, use default LLVM synch scope.
   if (!ScopeModel) {
-    assert(!UnimplementedFeature::syncScopeID());
+    assert(!MissingFeatures::syncScopeID());
     buildAtomicOp(CGF, Expr, Dest, Ptr, Val1, Val2, IsWeak, FailureOrder, Size,
                   Order, /*FIXME(cir): LLVM default scope*/ 1);
     return;
   }
 
   // Handle constant scope.
   if (getConstOpIntAttr(Scope)) {
-    assert(!UnimplementedFeature::syncScopeID());
+    assert(!MissingFeatures::syncScopeID());
     llvm_unreachable("NYI");
     return;
   }
@@ -1289,7 +1289,7 @@ void CIRGenFunction::buildAtomicStore(RValue rvalue, LValue dest,
       store.setIsVolatile(true);
 
     // DecorateInstructionWithTBAA
-    assert(!UnimplementedFeature::tbaa());
+    assert(!MissingFeatures::tbaa());
     return;
   }
 

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -12,7 +12,7 @@
 #include "Address.h"
 #include "CIRGenRecordLayout.h"
 #include "CIRGenTypeCache.h"
-#include "UnimplementedFeatureGuarding.h"
+#include "clang/CIR/MissingFeatures.h"
 
 #include "clang/AST/Decl.h"
 #include "clang/AST/Type.h"
@@ -406,7 +406,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(!UnimplementedFeature::isVarArg());
+    assert(!MissingFeatures::isVarArg());
     return getPointerTo(getPointerTo(fnTy));
   }
 
@@ -639,11 +639,11 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
   }
 
   mlir::Value createFSub(mlir::Value lhs, mlir::Value rhs) {
-    assert(!UnimplementedFeature::metaDataNode());
+    assert(!MissingFeatures::metaDataNode());
     if (IsFPConstrained)
       llvm_unreachable("Constrained FP NYI");
 
-    assert(!UnimplementedFeature::foldBinOpFMF());
+    assert(!MissingFeatures::foldBinOpFMF());
     return create<mlir::cir::BinOp>(lhs.getLoc(), mlir::cir::BinOpKind::Sub,
                                     lhs, rhs);
   }
@@ -660,7 +660,7 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
   mlir::Value createDynCastToVoid(mlir::Location loc, mlir::Value src,
                                   bool vtableUseRelativeLayout) {
     // TODO(cir): consider address space here.
-    assert(!UnimplementedFeature::addressSpace());
+    assert(!MissingFeatures::addressSpace());
     auto destTy = getVoidPtrTy();
     return create<mlir::cir::DynamicCastOp>(
         loc, destTy, mlir::cir::DynamicCastKind::ptr, src,
@@ -772,7 +772,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(!UnimplementedFeature::volatileLoadOrStore());
+    assert(!MissingFeatures::volatileLoadOrStore());
     return createAlignedLoad(loc, ty, ptr, align, /*isVolatile=*/false);
   }
 
@@ -913,7 +913,7 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
     auto memberPtrTy = memberPtr.getType().cast<mlir::cir::DataMemberType>();
 
     // TODO(cir): consider address space.
-    assert(!UnimplementedFeature::addressSpace());
+    assert(!MissingFeatures::addressSpace());
     auto resultTy = getPointerTo(memberPtrTy.getMemberTy());
 
     return create<mlir::cir::GetRuntimeMemberOp>(loc, resultTy, objectPtr,

clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp

@@ -16,7 +16,7 @@
 #include "CIRGenFunction.h"
 #include "CIRGenModule.h"
 #include "TargetInfo.h"
-#include "UnimplementedFeatureGuarding.h"
+#include "clang/CIR/MissingFeatures.h"
 
 // TODO(cir): we shouldn't need this but we currently reuse intrinsic IDs for
 // convenience.
@@ -717,7 +717,7 @@ RValue CIRGenFunction::buildBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
   }
   case Builtin::BI__builtin_unpredictable: {
     if (CGM.getCodeGenOpts().OptimizationLevel != 0)
-      assert(!UnimplementedFeature::insertBuiltinUnpredictable());
+      assert(!MissingFeatures::insertBuiltinUnpredictable());
     return RValue::get(buildScalarExpr(E->getArg(0)));
   }
 
@@ -978,7 +978,7 @@ RValue CIRGenFunction::buildBuiltinExpr(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(!UnimplementedFeature::addressSpace());
+    assert(!MissingFeatures::addressSpace());
     LangAS AAS = getASTAllocaAddressSpace();
     LangAS EAS = E->getType()->getPointeeType().getAddressSpace();
     if (EAS != AAS) {
@@ -1233,7 +1233,7 @@ mlir::Value CIRGenFunction::buildCheckedArgForBuiltin(const Expr *E,
   if (!SanOpts.has(SanitizerKind::Builtin))
     return value;
 
-  assert(!UnimplementedFeature::sanitizerBuiltin());
+  assert(!MissingFeatures::sanitizerBuiltin());
   llvm_unreachable("NYI");
 }
 

clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp

@@ -16,7 +16,7 @@
 #include "CIRGenFunction.h"
 #include "CIRGenModule.h"
 #include "TargetInfo.h"
-#include "UnimplementedFeatureGuarding.h"
+#include "clang/CIR/MissingFeatures.h"
 
 // TODO(cir): once all builtins are covered, decide whether we still
 // need to use LLVM intrinsics or if there's a better approach to follow. Right

clang/lib/CIR/CodeGen/CIRGenBuiltinX86.cpp

@@ -16,7 +16,7 @@
 #include "CIRGenFunction.h"
 #include "CIRGenModule.h"
 #include "TargetInfo.h"
-#include "UnimplementedFeatureGuarding.h"
+#include "clang/CIR/MissingFeatures.h"
 
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Value.h"

clang/lib/CIR/CodeGen/CIRGenCXX.cpp

@@ -38,7 +38,7 @@ bool CIRGenModule::tryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D) {
   //  an alias, unless this class owns no members.
   if (getCodeGenOpts().SanitizeMemoryUseAfterDtor &&
       !D->getParent()->field_empty())
-    assert(!UnimplementedFeature::sanitizeDtor());
+    assert(!MissingFeatures::sanitizeDtor());
 
   // If the destructor doesn't have a trivial body, we have to emit it
   // separately.

clang/lib/CIR/CodeGen/CIRGenCall.cpp

@@ -26,13 +26,13 @@
 #include "llvm/Support/ErrorHandling.h"
 #include <cassert>
 
-#include "UnimplementedFeatureGuarding.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/IR/Types.h"
+#include "clang/CIR/MissingFeatures.h"
 
 using namespace cir;
 using namespace clang;
@@ -164,7 +164,7 @@ void ClangToCIRArgMapping::construct(const ASTContext &Context,
       //
       // TODO(cir): a LLVM lowering prepare pass should break this down into
       // the appropriated pieces.
-      assert(!UnimplementedFeature::constructABIArgDirectExtend());
+      assert(!MissingFeatures::constructABIArgDirectExtend());
       CIRArgs.NumberOfArgs = 1;
       break;
     }
@@ -428,12 +428,12 @@ void CIRGenModule::ConstructAttributeList(StringRef Name,
     }
 
     if (TargetDecl->hasAttr<OpenCLKernelAttr>()) {
-      assert(!UnimplementedFeature::openCL());
+      assert(!MissingFeatures::openCL());
     }
 
     if (TargetDecl->hasAttr<CUDAGlobalAttr>() &&
         getLangOpts().OffloadUniformBlock)
-      assert(!UnimplementedFeature::CUDA());
+      assert(!MissingFeatures::CUDA());
 
     if (TargetDecl->hasAttr<ArmLocallyStreamingAttr>())
       ;
@@ -503,7 +503,7 @@ RValue CIRGenFunction::buildCall(const CIRGenFunctionInfo &CallInfo,
 
     // Some architectures (such as x86-64) have the ABI changed based on
     // attribute-target/features. Give them a chance to diagnose.
-    assert(!UnimplementedFeature::checkFunctionCallABI());
+    assert(!MissingFeatures::checkFunctionCallABI());
   }
 
   // TODO: add DNEBUG code
@@ -526,7 +526,7 @@ RValue CIRGenFunction::buildCall(const CIRGenFunctionInfo &CallInfo,
   // When passing arguments using temporary allocas, we need to add the
   // appropriate lifetime markers. This vector keeps track of all the lifetime
   // markers that need to be ended right after the call.
-  assert(!UnimplementedFeature::shouldEmitLifetimeMarkers() && "NYI");
+  assert(!MissingFeatures::shouldEmitLifetimeMarkers() && "NYI");
 
   // Translate all of the arguments as necessary to match the CIR lowering.
   assert(CallInfo.arg_size() == CallArgs.size() &&
@@ -841,7 +841,7 @@ mlir::Value CIRGenFunction::buildRuntimeCall(mlir::Location loc,
                                              mlir::cir::FuncOp callee,
                                              ArrayRef<mlir::Value> args) {
   // TODO(cir): set the calling convention to this runtime call.
-  assert(!UnimplementedFeature::setCallingConv());
+  assert(!MissingFeatures::setCallingConv());
 
   auto call = builder.create<mlir::cir::CallOp>(loc, callee, args);
   assert(call->getNumResults() <= 1 &&
@@ -1324,7 +1324,7 @@ arrangeFreeFunctionLikeCall(CIRGenTypes &CGT, CIRGenModule &CGM,
       addExtParameterInfosForCall(paramInfos, proto, numExtraRequiredArgs,
                                   args.size());
   } else if (llvm::isa<FunctionNoProtoType>(fnType)) {
-    assert(!UnimplementedFeature::targetCodeGenInfoIsProtoCallVariadic());
+    assert(!MissingFeatures::targetCodeGenInfoIsProtoCallVariadic());
     required = RequiredArgs(args.size());
   }