[CIR] Gracefully fail null getIdentifier() and large _BitInt

Fail gracefully when `getIdentifier()` for a declaration is null, such for
an overloaded operator.  Report an error and skip the declaration.

Fail gracefully when processing a large `_BitInt`, with a width greater
than 128.  Report an error and return `int` instead.

Remove the remaining fixed-point integral types from `convertType`.
Nothing can be done with them because fixed-point operations are not yet
implemented in the incubator, and I am not convinced that the types are
being converted correctly.

A couple small fixes to comments and documentation and formatting.

Author: dkolsen-pgi

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -99,7 +99,7 @@ def GlobalOp : CIR_Op<"global"> {
   let skipDefaultBuilders = 1;
 
   let builders = [OpBuilder<(ins "llvm::StringRef":$sym_name,
-		                             "mlir::Type":$sym_type)>];
+                                 "mlir::Type":$sym_type)>];
 
   let hasVerifier = 1;
 }
@@ -115,7 +115,7 @@ def GlobalOp : CIR_Op<"global"> {
 def FuncOp : CIR_Op<"func"> {
   let summary = "Declare or define a function";
   let description = [{
-    THe `cir.func` operation defines a function, similar to the `mlir::FuncOp`
+    The `cir.func` operation defines a function, similar to the `mlir::FuncOp`
     built-in.
   }];
 

clang/include/clang/CIR/Dialect/IR/CIRTypes.h

@@ -1,4 +1,4 @@
-//===- CIRTypes.h - MLIR CIR Types ------------------------------*- C++ -*-===//
+//===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -78,17 +78,27 @@ void CIRGenModule::emitGlobal(clang::GlobalDecl gd) {
 void CIRGenModule::emitGlobalFunctionDefinition(clang::GlobalDecl gd,
                                                 mlir::Operation *op) {
   auto const *funcDecl = cast<FunctionDecl>(gd.getDecl());
-  auto funcOp = builder.create<cir::FuncOp>(
-      getLoc(funcDecl->getSourceRange()), funcDecl->getIdentifier()->getName());
-  theModule.push_back(funcOp);
+  if (clang::IdentifierInfo *identifier = funcDecl->getIdentifier()) {
+    auto funcOp = builder.create<cir::FuncOp>(
+        getLoc(funcDecl->getSourceRange()), identifier->getName());
+    theModule.push_back(funcOp);
+  } else {
+    errorNYI(funcDecl->getSourceRange().getBegin(),
+             "function definition with a non-identifier for a name");
+  }
 }
 
 void CIRGenModule::emitGlobalVarDefinition(const clang::VarDecl *vd,
                                            bool isTentative) {
   mlir::Type type = getTypes().convertType(vd->getType());
-  auto varOp = builder.create<cir::GlobalOp>(
-      getLoc(vd->getSourceRange()), vd->getIdentifier()->getName(), type);
-  theModule.push_back(varOp);
+  if (clang::IdentifierInfo *identifier = vd->getIdentifier()) {
+    auto varOp = builder.create<cir::GlobalOp>(getLoc(vd->getSourceRange()),
+                                               identifier->getName(), type);
+    theModule.push_back(varOp);
+  } else {
+    errorNYI(vd->getSourceRange().getBegin(),
+             "variable definition with a non-identifier for a name");
+  }
 }
 
 void CIRGenModule::emitGlobalDefinition(clang::GlobalDecl gd,

clang/lib/CIR/CodeGen/CIRGenTypes.cpp

@@ -17,46 +17,37 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
   type = context.getCanonicalType(type);
   const Type *ty = type.getTypePtr();
 
+  // For types that haven't been implemented yet or are otherwise unsupported,
+  // report an error and return 'int'.
+
   mlir::Type resultType = nullptr;
   switch (ty->getTypeClass()) {
   case Type::Builtin: {
     switch (cast<BuiltinType>(ty)->getKind()) {
     // Signed types.
-    case BuiltinType::Accum:
     case BuiltinType::Char_S:
-    case BuiltinType::Fract:
     case BuiltinType::Int:
     case BuiltinType::Int128:
     case BuiltinType::Long:
-    case BuiltinType::LongAccum:
-    case BuiltinType::LongFract:
     case BuiltinType::LongLong:
     case BuiltinType::SChar:
     case BuiltinType::Short:
-    case BuiltinType::ShortAccum:
-    case BuiltinType::ShortFract:
     case BuiltinType::WChar_S:
       resultType = cir::IntType::get(cgm.getBuilder().getContext(),
                                      context.getTypeSize(ty),
                                      /*isSigned=*/true);
       break;
     // Unsigned types.
+    case BuiltinType::Char8:
     case BuiltinType::Char16:
     case BuiltinType::Char32:
-    case BuiltinType::Char8:
     case BuiltinType::Char_U:
-    case BuiltinType::UAccum:
     case BuiltinType::UChar:
-    case BuiltinType::UFract:
     case BuiltinType::UInt:
     case BuiltinType::UInt128:
     case BuiltinType::ULong:
-    case BuiltinType::ULongAccum:
-    case BuiltinType::ULongFract:
     case BuiltinType::ULongLong:
     case BuiltinType::UShort:
-    case BuiltinType::UShortAccum:
-    case BuiltinType::UShortFract:
     case BuiltinType::WChar_U:
       resultType = cir::IntType::get(cgm.getBuilder().getContext(),
                                      context.getTypeSize(ty),
@@ -72,9 +63,15 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
   }
   case Type::BitInt: {
     const auto *bitIntTy = cast<BitIntType>(type);
-    resultType =
-        cir::IntType::get(cgm.getBuilder().getContext(), bitIntTy->getNumBits(),
-                          bitIntTy->isSigned());
+    if (bitIntTy->getNumBits() > cir::IntType::maxBitwidth()) {
+      cgm.errorNYI(SourceLocation(), "large _BitInt type", type);
+      resultType = cir::IntType::get(cgm.getBuilder().getContext(), 32,
+                                     /*isSigned=*/true);
+    } else {
+      resultType =
+          cir::IntType::get(cgm.getBuilder().getContext(),
+                            bitIntTy->getNumBits(), bitIntTy->isSigned());
+    }
     break;
   }
   default: