[CIR] Integral types; simple global variables

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

@@ -15,6 +15,7 @@
 #define LLVM_CLANG_CIR_DIALECT_IR_CIROPS
 
 include "clang/CIR/Dialect/IR/CIRDialect.td"
+include "clang/CIR/Dialect/IR/CIRTypes.td"
 
 include "mlir/IR/BuiltinAttributeInterfaces.td"
 include "mlir/IR/EnumAttr.td"
@@ -74,6 +75,35 @@ class LLVMLoweringInfo {
 class CIR_Op<string mnemonic, list<Trait> traits = []> :
     Op<CIR_Dialect, mnemonic, traits>, LLVMLoweringInfo;
 
+//===----------------------------------------------------------------------===//
+// GlobalOp
+//===----------------------------------------------------------------------===//
+
+// TODO(CIR): For starters, cir.global has only name and type.  The other
+// properties of a global variable will be added over time as more of ClangIR
+// is upstreamed.
+
+def GlobalOp : CIR_Op<"global"> {
+  let summary = "Declare or define a global variable";
+  let description = [{
+    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);
+
+  let assemblyFormat = [{ $sym_name `:` $sym_type attr-dict }];
+
+  let skipDefaultBuilders = 1;
+
+  let builders = [OpBuilder<(ins "llvm::StringRef":$sym_name,
+                                 "mlir::Type":$sym_type)>];
+
+  let hasVerifier = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // FuncOp
 //===----------------------------------------------------------------------===//
@@ -85,14 +115,15 @@ class CIR_Op<string mnemonic, list<Trait> traits = []> :
 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);
 
   let skipDefaultBuilders = 1;
 
-  let builders = [OpBuilder<(ins "llvm::StringRef":$name)>];
+  let builders = [OpBuilder<(ins "llvm::StringRef":$sym_name)>];
 
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;

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

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the types in the CIR dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_CIR_IR_CIRTYPES_H_
+#define MLIR_DIALECT_CIR_IR_CIRTYPES_H_
+
+#include "mlir/IR/BuiltinAttributes.h"
+#include "mlir/IR/Types.h"
+#include "mlir/Interfaces/DataLayoutInterfaces.h"
+
+//===----------------------------------------------------------------------===//
+// CIR Dialect Tablegen'd Types
+//===----------------------------------------------------------------------===//
+
+#define GET_TYPEDEF_CLASSES
+#include "clang/CIR/Dialect/IR/CIROpsTypes.h.inc"
+
+#endif // MLIR_DIALECT_CIR_IR_CIRTYPES_H_

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

@@ -0,0 +1,132 @@
+//===- CIRTypes.td - CIR dialect types ---------------------*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the CIR dialect types.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_CIR_DIALECT_CIR_TYPES
+#define MLIR_CIR_DIALECT_CIR_TYPES
+
+include "clang/CIR/Dialect/IR/CIRDialect.td"
+include "mlir/Interfaces/DataLayoutInterfaces.td"
+include "mlir/IR/AttrTypeBase.td"
+
+//===----------------------------------------------------------------------===//
+// CIR Types
+//===----------------------------------------------------------------------===//
+
+class CIR_Type<string name, string typeMnemonic, list<Trait> traits = [],
+               string baseCppClass = "::mlir::Type">
+    : TypeDef<CIR_Dialect, name, traits, baseCppClass> {
+  let mnemonic = typeMnemonic;
+}
+
+//===----------------------------------------------------------------------===//
+// IntType
+//===----------------------------------------------------------------------===//
+
+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, 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`,
+    `long`, `long long`, and their unsigned variations.
+  }];
+  let parameters = (ins "unsigned":$width, "bool":$isSigned);
+  let hasCustomAssemblyFormat = 1;
+  let extraClassDeclaration = [{
+    /// Return true if this is a signed integer type.
+    bool isSigned() const { return getIsSigned(); }
+    /// Return true if this is an unsigned integer type.
+    bool isUnsigned() const { return !getIsSigned(); }
+    /// Return type alias.
+    std::string getAlias() const {
+      return (isSigned() ? 's' : 'u') + std::to_string(getWidth()) + 'i';
+    }
+    /// Return true if this is a primitive integer type (i.e. signed or unsigned
+    /// integer types whose bit width is 8, 16, 32, or 64).
+    bool isPrimitive() const {
+      return isValidPrimitiveIntBitwidth(getWidth());
+    }
+    bool isSignedPrimitive() const {
+      return isPrimitive() && isSigned();
+    }
+
+    /// Returns a minimum bitwidth of cir::IntType
+    static unsigned minBitwidth() { return 1; }
+    /// Returns a maximum bitwidth of cir::IntType
+    static unsigned maxBitwidth() { return 128; }
+
+    /// Returns true if cir::IntType that represents a primitive integer type
+    /// can be constructed from the provided bitwidth.
+    static bool isValidPrimitiveIntBitwidth(unsigned width) {
+      return width == 8 || width == 16 || width == 32 || width == 64;
+    }
+  }];
+  let genVerifyDecl = 1;
+}
+
+// Constraints
+
+// Unsigned integer type of a specific width.
+class UInt<int width>
+  : Type<And<[
+	CPred<"::mlir::isa<::cir::IntType>($_self)">,
+	CPred<"::mlir::cast<::cir::IntType>($_self).isUnsigned()">,
+	CPred<"::mlir::cast<::cir::IntType>($_self).getWidth() == " # width>
+        ]>, width # "-bit unsigned integer", "::cir::IntType">,
+    BuildableType<
+      "cir::IntType::get($_builder.getContext(), "
+      # width # ", /*isSigned=*/false)"> {
+  int bitwidth = width;
+}
+
+def UInt1  : UInt<1>;
+def UInt8  : UInt<8>;
+def UInt16 : UInt<16>;
+def UInt32 : UInt<32>;
+def UInt64 : UInt<64>;
+
+// Signed integer type of a specific width.
+class SInt<int width>
+  : Type<And<[
+	CPred<"::mlir::isa<::cir::IntType>($_self)">,
+	CPred<"::mlir::cast<::cir::IntType>($_self).isSigned()">,
+	CPred<"::mlir::cast<::cir::IntType>($_self).getWidth() == " # width>
+        ]>, width # "-bit signed integer", "::cir::IntType">,
+    BuildableType<
+      "cir::IntType::get($_builder.getContext(), "
+      # width # ", /*isSigned=*/true)"> {
+  int bitwidth = width;
+}
+
+def SInt1  : SInt<1>;
+def SInt8  : SInt<8>;
+def SInt16 : SInt<16>;
+def SInt32 : SInt<32>;
+def SInt64 : SInt<64>;
+
+def PrimitiveUInt
+    : AnyTypeOf<[UInt8, UInt16, UInt32, UInt64], "primitive unsigned int",
+                "::cir::IntType">;
+
+def PrimitiveSInt
+    : AnyTypeOf<[SInt8, SInt16, SInt32, SInt64], "primitive signed int",
+                "::cir::IntType">;
+
+def PrimitiveInt
+    : AnyTypeOf<[UInt8, UInt16, UInt32, UInt64, SInt8, SInt16, SInt32, SInt64],
+                "primitive int", "::cir::IntType">;
+
+#endif // MLIR_CIR_DIALECT_CIR_TYPES

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -31,7 +31,7 @@ CIRGenModule::CIRGenModule(mlir::MLIRContext &context,
                            DiagnosticsEngine &diags)
     : builder(&context), astCtx(astctx), langOpts(astctx.getLangOpts()),
       theModule{mlir::ModuleOp::create(mlir::UnknownLoc::get(&context))},
-      diags(diags), target(astCtx.getTargetInfo()) {}
+      diags(diags), target(astCtx.getTargetInfo()), genTypes(*this) {}
 
 mlir::Location CIRGenModule::getLoc(SourceLocation cLoc) {
   assert(cLoc.isValid() && "expected valid source location");
@@ -67,7 +67,8 @@ void CIRGenModule::emitGlobal(clang::GlobalDecl gd) {
       return;
     }
   } else {
-    errorNYI(global->getSourceRange(), "global variable declaration");
+    assert(cast<VarDecl>(global)->isFileVarDecl() &&
+           "Cannot emit local var decl as global");
   }
 
   // TODO(CIR): Defer emitting some global definitions until later
@@ -77,9 +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());
+  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,
@@ -103,6 +122,9 @@ void CIRGenModule::emitGlobalDefinition(clang::GlobalDecl gd,
     return;
   }
 
+  if (const auto *vd = dyn_cast<VarDecl>(decl))
+    return emitGlobalVarDefinition(vd, !vd->hasDefinition());
+
   llvm_unreachable("Invalid argument to CIRGenModule::emitGlobalDefinition");
 }
 
@@ -126,13 +148,13 @@ void CIRGenModule::emitTopLevelDecl(Decl *decl) {
       emitGlobal(fd);
     break;
   }
-  }
-}
 
-DiagnosticBuilder CIRGenModule::errorNYI(llvm::StringRef feature) {
-  unsigned diagID = diags.getCustomDiagID(
-      DiagnosticsEngine::Error, "ClangIR code gen Not Yet Implemented: %0");
-  return diags.Report(diagID) << feature;
+  case Decl::Var: {
+    auto *vd = cast<VarDecl>(decl);
+    emitGlobal(vd);
+    break;
+  }
+  }
 }
 
 DiagnosticBuilder CIRGenModule::errorNYI(SourceLocation loc,
@@ -142,21 +164,7 @@ DiagnosticBuilder CIRGenModule::errorNYI(SourceLocation loc,
   return diags.Report(loc, diagID) << feature;
 }
 
-DiagnosticBuilder CIRGenModule::errorNYI(SourceLocation loc,
-                                         llvm::StringRef feature,
-                                         llvm::StringRef name) {
-  unsigned diagID = diags.getCustomDiagID(
-      DiagnosticsEngine::Error, "ClangIR code gen Not Yet Implemented: %0: %1");
-  return diags.Report(loc, diagID) << feature << name;
-}
-
 DiagnosticBuilder CIRGenModule::errorNYI(SourceRange loc,
                                          llvm::StringRef feature) {
   return errorNYI(loc.getBegin(), feature) << loc;
 }
-
-DiagnosticBuilder CIRGenModule::errorNYI(SourceRange loc,
-                                         llvm::StringRef feature,
-                                         llvm::StringRef name) {
-  return errorNYI(loc.getBegin(), feature, name) << loc;
-}

clang/lib/CIR/CodeGen/CIRGenModule.h

@@ -14,23 +14,22 @@
 #define LLVM_CLANG_LIB_CIR_CODEGEN_CIRGENMODULE_H
 
 #include "CIRGenTypeCache.h"
+#include "CIRGenTypes.h"
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/MLIRContext.h"
+#include "clang/Basic/SourceManager.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace clang {
 class ASTContext;
 class CodeGenOptions;
 class Decl;
-class DiagnosticBuilder;
-class DiagnosticsEngine;
 class GlobalDecl;
 class LangOptions;
-class SourceLocation;
-class SourceRange;
 class TargetInfo;
+class VarDecl;
 
 namespace CIRGen {
 
@@ -64,8 +63,13 @@ class CIRGenModule : public CIRGenTypeCache {
 
   const clang::TargetInfo ⌖
 
+  CIRGenTypes genTypes;
+
 public:
   mlir::ModuleOp getModule() const { return theModule; }
+  mlir::OpBuilder &getBuilder() { return builder; }
+  clang::ASTContext &getASTContext() const { return astCtx; }
+  CIRGenTypes &getTypes() { return genTypes; }
 
   /// Helpers to convert the presumed location of Clang's SourceLocation to an
   /// MLIR Location.
@@ -81,13 +85,28 @@ class CIRGenModule : public CIRGenTypeCache {
   void emitGlobalDefinition(clang::GlobalDecl gd,
                             mlir::Operation *op = nullptr);
   void emitGlobalFunctionDefinition(clang::GlobalDecl gd, mlir::Operation *op);
+  void emitGlobalVarDefinition(const clang::VarDecl *vd,
+                               bool isTentative = false);
 
   /// Helpers to emit "not yet implemented" error diagnostics
-  DiagnosticBuilder errorNYI(llvm::StringRef);
   DiagnosticBuilder errorNYI(SourceLocation, llvm::StringRef);
-  DiagnosticBuilder errorNYI(SourceLocation, llvm::StringRef, llvm::StringRef);
+
+  template <typename T>
+  DiagnosticBuilder errorNYI(SourceLocation loc, llvm::StringRef feature,
+                             const T &name) {
+    unsigned diagID =
+        diags.getCustomDiagID(DiagnosticsEngine::Error,
+                              "ClangIR code gen Not Yet Implemented: %0: %1");
+    return diags.Report(loc, diagID) << feature << name;
+  }
+
   DiagnosticBuilder errorNYI(SourceRange, llvm::StringRef);
-  DiagnosticBuilder errorNYI(SourceRange, llvm::StringRef, llvm::StringRef);
+
+  template <typename T>
+  DiagnosticBuilder errorNYI(SourceRange loc, llvm::StringRef feature,
+                             const T &name) {
+    return errorNYI(loc.getBegin(), feature, name) << loc;
+  }
 };
 } // namespace CIRGen