[CIR] Remove saturated types; add _BitInt types

This is a follow-up commit to "Integral types; simple global variables"

Remove the saturated integral types from the type conversion code, since
I am not confident that they are implemented correctly.  They are part
of fixed-point support, which has not yet been implemented in ClangIR.

Add _BitInt types to the type conversion code, and add test cases for
them.

Improve the documentation for FuncOp, GlobalOp, and IntType.

Author: dkolsen-pgi

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

@@ -86,7 +86,10 @@ class CIR_Op<string mnemonic, list<Trait> traits = []> :
 def GlobalOp : CIR_Op<"global"> {
   let summary = "Declare or define a global variable";
   let description = [{
-    ... lots of text to be added later ...
+    The `cir.global` operation declares or defines a named global variable.
+
+    The backing memory for the variable is allocated statically and is
+    described by the type of the variable.
   }];
 
   let arguments = (ins SymbolNameAttr:$sym_name, TypeAttr:$sym_type);
@@ -112,7 +115,8 @@ def GlobalOp : CIR_Op<"global"> {
 def FuncOp : CIR_Op<"func"> {
   let summary = "Declare or define a function";
   let description = [{
-    ... lots of text to be added later ...
+    THe `cir.func` operation defines a function, similar to the `mlir::FuncOp`
+    built-in.
   }];
 
   let arguments = (ins SymbolNameAttr:$sym_name);

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

@@ -35,7 +35,9 @@ def CIR_IntType : CIR_Type<"Int", "int",
     [DeclareTypeInterfaceMethods<DataLayoutTypeInterface>]> {
   let summary = "Integer type with arbitrary precision up to a fixed limit";
   let description = [{
-    CIR type that represents integer types with arbitrary precision.
+    CIR type that represents integer types with arbitrary precision, including
+    standard integral types such as `int` and `long`, extended integral types
+    such as `__int128`, and arbitrary width types such as `_BitInt(n)`.
 
     Those integer types that are directly available in C/C++ standard are called
     primitive integer types. Said types are: `signed char`, `short`, `int`,

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -67,8 +67,8 @@ void CIRGenModule::emitGlobal(clang::GlobalDecl gd) {
       return;
     }
   } else {
-    const auto *vd = cast<VarDecl>(global);
-    assert(vd->isFileVarDecl() && "Cannot emit local var decl as global");
+    assert(cast<VarDecl>(global)->isFileVarDecl() &&
+           "Cannot emit local var decl as global");
   }
 
   // TODO(CIR): Defer emitting some global definitions until later

clang/lib/CIR/CodeGen/CIRGenTypes.cpp

@@ -36,13 +36,6 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
     case BuiltinType::ShortAccum:
     case BuiltinType::ShortFract:
     case BuiltinType::WChar_S:
-    // Saturated signed types.
-    case BuiltinType::SatAccum:
-    case BuiltinType::SatFract:
-    case BuiltinType::SatLongAccum:
-    case BuiltinType::SatLongFract:
-    case BuiltinType::SatShortAccum:
-    case BuiltinType::SatShortFract:
       resultType = cir::IntType::get(cgm.getBuilder().getContext(),
                                      context.getTypeSize(ty),
                                      /*isSigned=*/true);
@@ -65,13 +58,6 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
     case BuiltinType::UShortAccum:
     case BuiltinType::UShortFract:
     case BuiltinType::WChar_U:
-    // Saturated unsigned types.
-    case BuiltinType::SatUAccum:
-    case BuiltinType::SatUFract:
-    case BuiltinType::SatULongAccum:
-    case BuiltinType::SatULongFract:
-    case BuiltinType::SatUShortAccum:
-    case BuiltinType::SatUShortFract:
       resultType = cir::IntType::get(cgm.getBuilder().getContext(),
                                      context.getTypeSize(ty),
                                      /*isSigned=*/false);
@@ -84,6 +70,13 @@ mlir::Type CIRGenTypes::convertType(QualType type) {
     }
     break;
   }
+  case Type::BitInt: {
+    const auto *bitIntTy = cast<BitIntType>(type);
+    resultType =
+        cir::IntType::get(cgm.getBuilder().getContext(), bitIntTy->getNumBits(),
+                          bitIntTy->isSigned());
+    break;
+  }
   default:
     cgm.errorNYI(SourceLocation(), "processing of type", type);
     resultType =

clang/test/CIR/global-var-simple.cpp

@@ -51,3 +51,9 @@ char16_t c16;
 
 char32_t c32;
 // CHECK: cir.global @c32 : !cir.int<u, 32>
+
+_BitInt(20) sb20;
+// CHECK: cir.global @sb20 : !cir.int<s, 20>
+
+unsigned _BitInt(48) ub48;
+// CHECK: cir.global @ub48 : !cir.int<u, 48>