Revert "[CIR] Upstream basic alloca and load support (llvm#128792)"

This reverts commit 3989b78.

Author: lanza

clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h

@@ -9,7 +9,6 @@
 #ifndef LLVM_CLANG_CIR_DIALECT_BUILDER_CIRBASEBUILDER_H
 #define LLVM_CLANG_CIR_DIALECT_BUILDER_CIRBASEBUILDER_H
 
-#include "clang/AST/CharUnits.h"
 #include "clang/CIR/Dialect/IR/CIRAttrs.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
 #include "clang/CIR/Dialect/IR/CIRTypes.h"
@@ -52,47 +51,6 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
     return cir::ConstPtrAttr::get(
         getContext(), mlir::cast<cir::PointerType>(type), valueAttr);
   }
-
-  mlir::Value createAlloca(mlir::Location loc, cir::PointerType addrType,
-                           mlir::Type type, llvm::StringRef name,
-                           mlir::IntegerAttr alignment) {
-    return create<cir::AllocaOp>(loc, addrType, type, name, alignment);
-  }
-
-  cir::LoadOp createLoad(mlir::Location loc, mlir::Value ptr,
-                         bool isVolatile = false, uint64_t alignment = 0) {
-    mlir::IntegerAttr intAttr;
-    if (alignment)
-      intAttr = mlir::IntegerAttr::get(
-          mlir::IntegerType::get(ptr.getContext(), 64), alignment);
-
-    return create<cir::LoadOp>(loc, ptr);
-  }
-
-  //
-  // Block handling helpers
-  // ----------------------
-  //
-  static OpBuilder::InsertPoint getBestAllocaInsertPoint(mlir::Block *block) {
-    auto last =
-        std::find_if(block->rbegin(), block->rend(), [](mlir::Operation &op) {
-          // TODO: Add LabelOp missing feature here
-          return mlir::isa<cir::AllocaOp>(&op);
-        });
-
-    if (last != block->rend())
-      return OpBuilder::InsertPoint(block, ++mlir::Block::iterator(&*last));
-    return OpBuilder::InsertPoint(block, block->begin());
-  };
-
-  mlir::IntegerAttr getSizeFromCharUnits(mlir::MLIRContext *ctx,
-                                         clang::CharUnits size) {
-    // Note that mlir::IntegerType is used instead of cir::IntType here
-    // because we don't need sign information for this to be useful, so keep
-    // it simple.
-    return mlir::IntegerAttr::get(mlir::IntegerType::get(ctx, 64),
-                                  size.getQuantity());
-  }
 };
 
 } // namespace cir

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

@@ -54,21 +54,6 @@ def CIR_BoolAttr : CIR_Attr<"Bool", "bool", [TypedAttrInterface]> {
   }];
 }
 
-//===----------------------------------------------------------------------===//
-// UndefAttr
-//===----------------------------------------------------------------------===//
-
-def UndefAttr : CIR_Attr<"Undef", "undef", [TypedAttrInterface]> {
-  let summary = "Represent an undef constant";
-  let description = [{
-    The UndefAttr represents an undef constant, corresponding to LLVM's notion
-    of undef.
-  }];
-
-  let parameters = (ins AttributeSelfTypeParameter<"">:$type);
-  let assemblyFormat = [{}];
-}
-
 //===----------------------------------------------------------------------===//
 // IntegerAttr
 //===----------------------------------------------------------------------===//

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

@@ -115,119 +115,6 @@ def ConstantOp : CIR_Op<"const",
   let hasFolder = 1;
 }
 
-//===----------------------------------------------------------------------===//
-// AllocaOp
-//===----------------------------------------------------------------------===//
-
-class AllocaTypesMatchWith<string summary, string lhsArg, string rhsArg,
-                     string transform, string comparator = "std::equal_to<>()">
-  : PredOpTrait<summary, CPred<
-      comparator # "(" #
-      !subst("$_self", "$" # lhsArg # ".getType()", transform) #
-             ", $" # rhsArg # ")">> {
-  string lhs = lhsArg;
-  string rhs = rhsArg;
-  string transformer = transform;
-}
-
-def AllocaOp : CIR_Op<"alloca", [
-  AllocaTypesMatchWith<"'allocaType' matches pointee type of 'addr'",
-                 "addr", "allocaType",
-                 "cast<PointerType>($_self).getPointee()">,
-                 DeclareOpInterfaceMethods<PromotableAllocationOpInterface>]> {
-  let summary = "Defines a scope-local variable";
-  let description = [{
-    The `cir.alloca` operation defines a scope-local variable.
-
-    The presence of the `const` attribute indicates that the local variable is
-    declared with C/C++ `const` keyword.
-
-    The result type is a pointer to the input's type.
-
-    Example:
-
-    ```mlir
-    // int count;
-    %0 = cir.alloca i32, !cir.ptr<i32>, ["count"] {alignment = 4 : i64}
-
-    // int *ptr;
-    %1 = cir.alloca !cir.ptr<i32>, !cir.ptr<!cir.ptr<i32>>, ["ptr"] {alignment = 8 : i64}
-    ...
-    ```
-  }];
-
-  let arguments = (ins
-    TypeAttr:$allocaType,
-    StrAttr:$name,
-    UnitAttr:$init,
-    UnitAttr:$constant,
-    ConfinedAttr<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$alignment,
-    OptionalAttr<ArrayAttr>:$annotations
-  );
-
-  let results = (outs Res<CIR_PointerType, "",
-                      [MemAlloc<AutomaticAllocationScopeResource>]>:$addr);
-
-  let skipDefaultBuilders = 1;
-  let builders = [
-    OpBuilder<(ins "mlir::Type":$addr,
-                   "mlir::Type":$allocaType,
-                   "llvm::StringRef":$name,
-                   "mlir::IntegerAttr":$alignment)>
-  ];
-
-  let extraClassDeclaration = [{
-    // Whether the alloca input type is a pointer.
-    bool isPointerType() { return ::mlir::isa<::cir::PointerType>(getAllocaType()); }
-  }];
-
-  let assemblyFormat = [{
-    $allocaType `,` qualified(type($addr)) `,`
-    `[` $name
-       (`,` `init` $init^)?
-       (`,` `const` $constant^)?
-    `]`
-    ($annotations^)? attr-dict
-  }];
-
-  let hasVerifier = 0;
-}
-
-//===----------------------------------------------------------------------===//
-// LoadOp
-//===----------------------------------------------------------------------===//
-
-def LoadOp : CIR_Op<"load", [
-  TypesMatchWith<"type of 'result' matches pointee type of 'addr'",
-                 "addr", "result",
-                 "cast<PointerType>($_self).getPointee()">,
-                 DeclareOpInterfaceMethods<PromotableMemOpInterface>]> {
-
-  let summary = "Load value from memory adddress";
-  let description = [{
-    `cir.load` reads a value (lvalue to rvalue conversion) given an address
-    backed up by a `cir.ptr` type.
-
-    Example:
-
-    ```mlir
-
-    // Read from local variable, address in %0.
-    %1 = cir.load %0 : !cir.ptr<i32>, i32
-    ```
-  }];
-
-  let arguments = (ins Arg<CIR_PointerType, "the address to load from",
-                           [MemRead]>:$addr);
-  let results = (outs CIR_AnyType:$result);
-
-  let assemblyFormat = [{
-    $addr `:` qualified(type($addr)) `,` type($result) attr-dict
-  }];
-
-  // FIXME: add verifier.
-}
-
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//

clang/include/clang/CIR/MissingFeatures.h

@@ -30,35 +30,12 @@ struct MissingFeatures {
   // This isn't needed until we add support for bools.
   static bool convertTypeForMemory() { return false; }
 
-  // CIRGenFunction implementation details
-  static bool cgfSymbolTable() { return false; }
-
   // Unhandled global/linkage information.
   static bool opGlobalDSOLocal() { return false; }
   static bool opGlobalThreadLocal() { return false; }
   static bool opGlobalConstant() { return false; }
   static bool opGlobalAlignment() { return false; }
   static bool opGlobalLinkage() { return false; }
-
-  // Load attributes
-  static bool opLoadThreadLocal() { return false; }
-  static bool opLoadEmitScalarRangeCheck() { return false; }
-  static bool opLoadBooleanRepresentation() { return false; }
-
-  // AllocaOp handling
-  static bool opAllocaVarDeclContext() { return false; }
-  static bool opAllocaStaticLocal() { return false; }
-  static bool opAllocaNonGC() { return false; }
-  static bool opAllocaImpreciseLifetime() { return false; }
-  static bool opAllocaPreciseLifetime() { return false; }
-  static bool opAllocaTLS() { return false; }
-  static bool opAllocaOpenMPThreadPrivate() { return false; }
-  static bool opAllocaEscapeByReference() { return false; }
-  static bool opAllocaReference() { return false; }
-
-  // Misc
-  static bool scalarConversionOpts() { return false; }
-  static bool tryEmitAsConstant() { return false; }
 };
 
 } // namespace cir