[CIR][CIRGen][LLVMLowering] Add support retrieving thread local global addresses

Author: bcardosolopes

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

@@ -1775,24 +1775,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

@@ -719,11 +719,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

@@ -836,11 +836,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

@@ -1634,9 +1634,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

@@ -1613,7 +1613,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();
   }
 };

clang/test/CIR/CodeGen/tls.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/IR/global.cir

@@ -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/invalid.cir

@@ -1033,3 +1033,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
+  }
+}