Revert "[CIR][LLVMLowering] Lower cir.objectsize (#545)"

This reverts commit 87a61f3.

It's deleting code it isn't supposed to touch.

Author: bcardosolopes

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

@@ -1776,24 +1776,31 @@ def GetGlobalOp : CIR_Op<"get_global",
     [Pure, DeclareOpInterfaceMethods<SymbolUserOpInterface>]> {
   let summary = "Get the address of a global variable";
   let description = [{
-     The `cir.get_global` operation retrieves the address pointing to a
-     named global variable. If the global variable is marked constant, writing
-     to the resulting address (such as through a `cir.store` operation) is
-     undefined. Resulting type must always be a `!cir.ptr<...>` type.
+    The `cir.get_global` operation retrieves the address pointing to a
+    named global variable. If the global variable is marked constant, writing
+    to the resulting address (such as through a `cir.store` operation) is
+    undefined. Resulting type must always be a `!cir.ptr<...>` type.
 
-     Example:
+    Addresses of thread local globals can only be retrieved if this operation
+    is marked `thread_local`, which indicates the address isn't constant.
 
-     ```mlir
-     %x = cir.get_global @foo : !cir.ptr<i32>
-     ```
+    Example:
+    ```mlir
+    %x = cir.get_global @foo : !cir.ptr<i32>
+    ...
+    %y = cir.get_global thread_local @batata : !cir.ptr<i32>
+    ```
   }];
 
-  let arguments = (ins FlatSymbolRefAttr:$name);
+  let arguments = (ins FlatSymbolRefAttr:$name, UnitAttr:$tls);
   let results = (outs Res<CIR_PointerType, "", []>:$addr);
 
   // FIXME: we should not be printing `cir.ptr` below, that should come
   // from the pointer type directly.
-  let assemblyFormat = "$name `:` `cir.ptr` type($addr) attr-dict";
+  let assemblyFormat = [{
+    (`thread_local` $tls^)?
+    $name `:` `cir.ptr` type($addr) attr-dict
+  }];
 
   // `GetGlobalOp` is fully verified by its traits.
   let hasVerifier = 0;

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -697,9 +697,11 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
     return create<mlir::cir::GlobalOp>(loc, uniqueName, type, isConst, linkage);
   }
 
-  mlir::Value createGetGlobal(mlir::cir::GlobalOp global) {
-    return create<mlir::cir::GetGlobalOp>(
-        global.getLoc(), getPointerTo(global.getSymType()), global.getName());
+  mlir::Value createGetGlobal(mlir::cir::GlobalOp global,
+                              bool threadLocal = false) {
+    return create<mlir::cir::GetGlobalOp>(global.getLoc(),
+                                          getPointerTo(global.getSymType()),
+                                          global.getName(), threadLocal);
   }
 
   mlir::Value createGetBitfield(mlir::Location loc, mlir::Type resultType,

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -720,11 +720,10 @@ static LValue buildGlobalVarDeclLValue(CIRGenFunction &CGF, const Expr *E,
   if (CGF.getLangOpts().OpenMP)
     llvm_unreachable("not implemented");
 
+  // Traditional LLVM codegen handles thread local separately, CIR handles
+  // as part of getAddrOfGlobalVar.
   auto V = CGF.CGM.getAddrOfGlobalVar(VD);
 
-  if (VD->getTLSKind() != VarDecl::TLS_None)
-    llvm_unreachable("NYI");
-
   auto RealVarTy = CGF.getTypes().convertTypeForMem(VD->getType());
   auto realPtrTy = CGF.getBuilder().getPointerTo(RealVarTy);
   if (realPtrTy != V.getType())

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -837,11 +837,12 @@ mlir::Value CIRGenModule::getAddrOfGlobalVar(const VarDecl *D, mlir::Type Ty,
   if (!Ty)
     Ty = getTypes().convertTypeForMem(ASTTy);
 
+  bool tlsAccess = D->getTLSKind() != VarDecl::TLS_None;
   auto g = buildGlobal(D, Ty, IsForDefinition);
   auto ptrTy =
       mlir::cir::PointerType::get(builder.getContext(), g.getSymType());
-  return builder.create<mlir::cir::GetGlobalOp>(getLoc(D->getSourceRange()),
-                                                ptrTy, g.getSymName());
+  return builder.create<mlir::cir::GetGlobalOp>(
+      getLoc(D->getSourceRange()), ptrTy, g.getSymName(), tlsAccess);
 }
 
 mlir::cir::GlobalViewAttr

clang/lib/CIR/Dialect/IR/CIRDialect.cpp

@@ -1635,9 +1635,13 @@ GetGlobalOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
            << "' does not reference a valid cir.global or cir.func";
 
   mlir::Type symTy;
-  if (auto g = dyn_cast<GlobalOp>(op))
+  if (auto g = dyn_cast<GlobalOp>(op)) {
     symTy = g.getSymType();
-  else if (auto f = dyn_cast<FuncOp>(op))
+    // Verify that for thread local global access, the global needs to
+    // be marked with tls bits.
+    if (getTls() && !g.getTlsModel())
+      return emitOpError("access to global not marked thread local");
+  } else if (auto f = dyn_cast<FuncOp>(op))
     symTy = f.getFunctionType();
   else
     llvm_unreachable("shall not get here");

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -1627,7 +1627,16 @@ class CIRGetGlobalOpLowering
 
     auto type = getTypeConverter()->convertType(op.getType());
     auto symbol = op.getName();
-    rewriter.replaceOpWithNewOp<mlir::LLVM::AddressOfOp>(op, type, symbol);
+    mlir::Operation *newop =
+        rewriter.create<mlir::LLVM::AddressOfOp>(op.getLoc(), type, symbol);
+
+    if (op.getTls()) {
+      // Handle access to TLS via intrinsic.
+      newop = rewriter.create<mlir::LLVM::ThreadlocalAddressOp>(
+          op.getLoc(), type, newop->getResult(0));
+    }
+
+    rewriter.replaceOp(op, newop);
     return mlir::success();
   }
 };
@@ -2292,36 +2301,6 @@ class CIRBitClrsbOpLowering
   }
 };
 
-class CIRObjSizeOpLowering
-    : public mlir::OpConversionPattern<mlir::cir::ObjSizeOp> {
-public:
-  using OpConversionPattern<mlir::cir::ObjSizeOp>::OpConversionPattern;
-
-  mlir::LogicalResult
-  matchAndRewrite(mlir::cir::ObjSizeOp op, OpAdaptor adaptor,
-                  mlir::ConversionPatternRewriter &rewriter) const override {
-    auto llvmResTy = getTypeConverter()->convertType(op.getType());
-    auto loc = op->getLoc();
-
-    auto llvmIntrinNameAttr =
-        mlir::StringAttr::get(rewriter.getContext(), "llvm.objectsize");
-    mlir::cir::SizeInfoType kindInfo = op.getKind();
-    auto falseValue = rewriter.create<mlir::LLVM::ConstantOp>(
-        loc, rewriter.getI1Type(), false);
-    auto trueValue = rewriter.create<mlir::LLVM::ConstantOp>(
-        loc, rewriter.getI1Type(), true);
-
-    rewriter.replaceOpWithNewOp<mlir::LLVM::CallIntrinsicOp>(
-        op, llvmResTy, llvmIntrinNameAttr,
-        mlir::ValueRange{adaptor.getPtr(),
-                         kindInfo == mlir::cir::SizeInfoType::max ? falseValue
-                                                                  : trueValue,
-                         trueValue, op.getDynamic() ? trueValue : falseValue});
-
-    return mlir::LogicalResult::success();
-  }
-};
-
 class CIRBitClzOpLowering
     : public mlir::OpConversionPattern<mlir::cir::BitClzOp> {
 public:
@@ -3085,8 +3064,8 @@ void populateCIRToLLVMConversionPatterns(mlir::RewritePatternSet &patterns,
       CIRVectorShuffleVecLowering, CIRStackSaveLowering,
       CIRStackRestoreLowering, CIRUnreachableLowering, CIRTrapLowering,
       CIRInlineAsmOpLowering, CIRSetBitfieldLowering, CIRGetBitfieldLowering,
-      CIRPrefetchLowering, CIRObjSizeOpLowering, CIRIsConstantOpLowering>(
-      converter, patterns.getContext());
+      CIRPrefetchLowering, CIRIsConstantOpLowering>(converter,
+                                                    patterns.getContext());
 }
 
 namespace {

clang/test/CIR/CodeGen/pass-object-size.c

@@ -3,6 +3,17 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.ll
 // RUN: FileCheck --check-prefix=LLVM --input-file=%t.ll %s
 
+extern __thread int b;
+int c(void) { return *&b; }
+// CIR: cir.global "private" external tls_dyn @b : !s32i
+// CIR: cir.func @c() -> !s32i
+// CIR:   %[[TLS_ADDR:.*]] = cir.get_global thread_local @b : cir.ptr <!s32i>
+
 __thread int a;
 // CIR: cir.global external tls_dyn @a = #cir.int<0> : !s32i
+
+// LLVM: @b = external thread_local global i32
 // LLVM: @a = thread_local global i32 0
+
+// LLVM-LABEL: @c
+// LLVM: = call ptr @llvm.threadlocal.address.p0(ptr @b)

clang/test/CIR/CodeGen/tls.c

@@ -63,6 +63,12 @@ module {
   cir.global external tls_local_dyn @model1 = #cir.int<0> : !s32i
   cir.global external tls_init_exec @model2 = #cir.int<0> : !s32i
   cir.global external tls_local_exec @model3 = #cir.int<0> : !s32i
+
+  cir.global "private" external tls_dyn @batata : !s32i
+  cir.func @f35() {
+    %0 = cir.get_global thread_local @batata : cir.ptr <!s32i>
+    cir.return
+  }
 }
 
 // CHECK: cir.global external @a = #cir.int<3> : !s32i
@@ -91,4 +97,10 @@ module {
 // CHECK: cir.global external tls_dyn @model0 = #cir.int<0> : !s32i
 // CHECK: cir.global external tls_local_dyn @model1 = #cir.int<0> : !s32i
 // CHECK: cir.global external tls_init_exec @model2 = #cir.int<0> : !s32i
-// CHECK: cir.global external tls_local_exec @model3 = #cir.int<0> : !s32i
+// CHECK: cir.global external tls_local_exec @model3 = #cir.int<0> : !s32i
+
+// CHECK: cir.global "private" external tls_dyn @batata : !s32i
+// CHECK: cir.func @f35() {
+// CHECK:   %0 = cir.get_global thread_local @batata : cir.ptr <!s32i>
+// CHECK:   cir.return
+// CHECK: }

clang/test/CIR/IR/global.cir

@@ -1034,3 +1034,16 @@ cir.func @bad_fetch(%x: !cir.ptr<!cir.float>, %y: !cir.float) -> () {
   %12 = cir.atomic.fetch(xor, %x : !cir.ptr<!cir.float>, %y : !cir.float, seq_cst) : !cir.float
   cir.return
 }
+
+// -----
+
+!s32i = !cir.int<s, 32>
+
+module {
+  cir.global "private" external @batata : !s32i
+  cir.func @f35() {
+    // expected-error@+1 {{access to global not marked thread local}}
+    %0 = cir.get_global thread_local @batata : cir.ptr <!s32i>
+    cir.return
+  }
+}