Revert "[CIR] Integral types; simple global variables (llvm#118743)"

This reverts commit a43b2e1.

Author: lanza

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

@@ -15,7 +15,6 @@
 #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"
@@ -75,35 +74,6 @@ 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
 //===----------------------------------------------------------------------===//
@@ -115,15 +85,14 @@ 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`
-    built-in.
+    ... lots of text to be added later ...
   }];
 
   let arguments = (ins SymbolNameAttr:$sym_name);
 
   let skipDefaultBuilders = 1;
 
-  let builders = [OpBuilder<(ins "llvm::StringRef":$sym_name)>];
+  let builders = [OpBuilder<(ins "llvm::StringRef":$name)>];
 
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;

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

@@ -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()), genTypes(*this) {}
+      diags(diags), target(astCtx.getTargetInfo()) {}
 
 mlir::Location CIRGenModule::getLoc(SourceLocation cLoc) {
   assert(cLoc.isValid() && "expected valid source location");
@@ -67,8 +67,7 @@ void CIRGenModule::emitGlobal(clang::GlobalDecl gd) {
       return;
     }
   } else {
-    assert(cast<VarDecl>(global)->isFileVarDecl() &&
-           "Cannot emit local var decl as global");
+    errorNYI(global->getSourceRange(), "global variable declaration");
   }
 
   // TODO(CIR): Defer emitting some global definitions until later
@@ -78,27 +77,9 @@ void CIRGenModule::emitGlobal(clang::GlobalDecl gd) {
 void CIRGenModule::emitGlobalFunctionDefinition(clang::GlobalDecl gd,
                                                 mlir::Operation *op) {
   auto const *funcDecl = cast<FunctionDecl>(gd.getDecl());
-  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");
-  }
+  auto funcOp = builder.create<cir::FuncOp>(
+      getLoc(funcDecl->getSourceRange()), funcDecl->getIdentifier()->getName());
+  theModule.push_back(funcOp);
 }
 
 void CIRGenModule::emitGlobalDefinition(clang::GlobalDecl gd,
@@ -122,9 +103,6 @@ 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");
 }
 
@@ -148,23 +126,37 @@ void CIRGenModule::emitTopLevelDecl(Decl *decl) {
       emitGlobal(fd);
     break;
   }
-
-  case Decl::Var: {
-    auto *vd = cast<VarDecl>(decl);
-    emitGlobal(vd);
-    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;
+}
+
 DiagnosticBuilder CIRGenModule::errorNYI(SourceLocation loc,
                                          llvm::StringRef feature) {
   unsigned diagID = diags.getCustomDiagID(
       DiagnosticsEngine::Error, "ClangIR code gen Not Yet Implemented: %0");
   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/include/clang/CIR/Dialect/IR/CIRTypes.td

@@ -14,22 +14,23 @@
 #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 {
 
@@ -63,13 +64,8 @@ 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.
@@ -85,28 +81,13 @@ 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);
-
-  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(SourceLocation, llvm::StringRef, llvm::StringRef);
   DiagnosticBuilder errorNYI(SourceRange, llvm::StringRef);
-
-  template <typename T>
-  DiagnosticBuilder errorNYI(SourceRange loc, llvm::StringRef feature,
-                             const T &name) {
-    return errorNYI(loc.getBegin(), feature, name) << loc;
-  }
+  DiagnosticBuilder errorNYI(SourceRange, llvm::StringRef, llvm::StringRef);
 };
 } // namespace CIRGen