[CIR] Add support for thread-local storage (TLS) #168662
Open
+862
−22
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This implements the builtins that handle overflow.
Co-authored-by: Henrich Lauko <henrich.lau@gmail.com>
Co-authored-by: Henrich Lauko <henrich.lau@gmail.com>
Co-authored-by: Andy Kaylor <akaylor@nvidia.com>
Co-authored-by: Andy Kaylor <akaylor@nvidia.com>
Co-authored-by: Andy Kaylor <akaylor@nvidia.com>
Co-authored-by: Andy Kaylor <akaylor@nvidia.com>
Co-authored-by: Andy Kaylor <akaylor@nvidia.com>
Remove the BinOpOverflowResults struct and createBinOpOverflowOp helper function from CIRBaseBuilder. Instead, call cir::BinOpOverflowOp::create directly and use getResult() and getOverflow() on the returned operation. This simplifies the API and makes it more natural to use, as suggested by reviewer feedback.
Replace auto with explicit types and use lowerCamelCase. Replace deprecated rewriter.create with Op::create.
- Rename 'signed' field to 'isSigned' (signed is a keyword) - Use lowerCamelCase for all variables and parameters - Replace createBinOpOverflowOp helper with direct BinOpOverflowOp::create calls
This commit adds full support for thread-local storage variables in ClangIR, including code generation, lowering to LLVM IR, and comprehensive testing. Changes include: - Added CIR_TLSModel enum with 4 TLS models (GeneralDynamic, LocalDynamic, InitialExec, LocalExec) to CIROps.td - Extended GlobalOp with optional tls_model attribute - Extended GetGlobalOp with thread_local unit attribute - Added verification to ensure thread_local GetGlobalOp references globals with tls_model set - Implemented GetDefaultCIRTLSModel() and setTLSMode() in CIRGenModule - Updated getAddrOfGlobalVar() to handle TLS access - Removed MissingFeatures assertions for TLS operations - Added lowering of GetGlobalOp with TLS to llvm.threadlocal.address intrinsic - Added lowering of GlobalOp with tls_model to LLVM thread_local globals - Added comprehensive test with CIR, LLVM, and OGCG checks Known limitations (matching incubator): - Static local TLS variables not yet implemented - TLS_Dynamic with wrapper functions not yet implemented This fixes issue llvm#153270
adams381
requested review from
andykaylor,
bcardosolopes,
lanza and
xlauko
as code owners
|
Thank you for submitting a Pull Request (PR) to the LLVM Project! This PR will be automatically labeled and the relevant teams will be notified. If you wish to, you can add reviewers by using the "Reviewers" section on this page. If this is not working for you, it is probably because you do not have write permissions for the repository. In which case you can instead tag reviewers by name in a comment by using If you have received no comments on your PR for a week, you can request a review by "ping"ing the PR by adding a comment “Ping”. The common courtesy "ping" rate is once a week. Please remember that you are asking for valuable time from other developers. If you have further questions, they may be answered by the LLVM GitHub User Guide. You can also ask questions in a comment on this PR, on the LLVM Discord or on the forums. |
Contributor
You can use this format. |
Member
|
@llvm/pr-subscribers-clangir Author: None (adams381) ChangesThis commit adds full support for thread-local storage variables in ClangIR, including code generation, lowering to LLVM IR, and comprehensive testing. Changes include:
Known limitations (matching incubator):
This fixes issue #153270 Patch is 49.78 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/168662.diff 11 Files Affected:
diff --git a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h
index 3288f5b12c77e..7bafa42df2739 100644
--- a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h
+++ b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h
@@ -300,14 +300,17 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
return cir::GlobalViewAttr::get(type, symbol, indices);
}
- mlir::Value createGetGlobal(mlir::Location loc, cir::GlobalOp global) {
+ mlir::Value createGetGlobal(mlir::Location loc, cir::GlobalOp global,
+ bool threadLocal = false) {
assert(!cir::MissingFeatures::addressSpace());
- return cir::GetGlobalOp::create(
- *this, loc, getPointerTo(global.getSymType()), global.getSymName());
+ auto getGlobalOp = cir::GetGlobalOp::create(
+ *this, loc, getPointerTo(global.getSymType()), global.getSymNameAttr(),
+ threadLocal);
+ return getGlobalOp.getAddr();
}
- mlir::Value createGetGlobal(cir::GlobalOp global) {
- return createGetGlobal(global.getLoc(), global);
+ mlir::Value createGetGlobal(cir::GlobalOp global, bool threadLocal = false) {
+ return createGetGlobal(global.getLoc(), global, threadLocal);
}
/// Create a copy with inferred length.
diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td
index dc56db1bbd4ea..1200fc049b087 100644
--- a/clang/include/clang/CIR/Dialect/IR/CIROps.td
+++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td
@@ -1628,6 +1628,82 @@ def CIR_CmpOp : CIR_Op<"cmp", [Pure, SameTypeOperands]> {
let isLLVMLoweringRecursive = true;
}
+//===----------------------------------------------------------------------===//
+// BinOpOverflowOp
+//===----------------------------------------------------------------------===//
+
+def CIR_BinOpOverflowKind : CIR_I32EnumAttr<
+ "BinOpOverflowKind", "checked binary arithmetic operation kind", [
+ I32EnumAttrCase<"Add", 0, "add">,
+ I32EnumAttrCase<"Sub", 1, "sub">,
+ I32EnumAttrCase<"Mul", 2, "mul">
+]>;
+
+def CIR_BinOpOverflowOp : CIR_Op<"binop.overflow", [Pure, SameTypeOperands]> {
+ let summary = "Perform binary integral arithmetic with overflow checking";
+ let description = [{
+ `cir.binop.overflow` performs binary arithmetic operations with overflow
+ checking on integral operands.
+
+ The `kind` argument specifies the kind of arithmetic operation to perform.
+ It can be either `add`, `sub`, or `mul`. The `lhs` and `rhs` arguments
+ specify the input operands of the arithmetic operation. The types of `lhs`
+ and `rhs` must be the same.
+
+ `cir.binop.overflow` produces two SSA values. `result` is the result of the
+ arithmetic operation truncated to its specified type. `overflow` is a
+ boolean value indicating whether overflow happens during the operation.
+
+ The exact semantic of this operation is as follows:
+
+ - `lhs` and `rhs` are promoted to an imaginary integral type that has
+ infinite precision.
+ - The arithmetic operation is performed on the promoted operands.
+ - The infinite-precision result is truncated to the type of `result`. The
+ truncated result is assigned to `result`.
+ - If the truncated result is equal to the un-truncated result, `overflow`
+ is assigned to false. Otherwise, `overflow` is assigned to true.
+ }];
+
+ let arguments = (ins
+ CIR_BinOpOverflowKind:$kind,
+ CIR_IntType:$lhs,
+ CIR_IntType:$rhs
+ );
+
+ let results = (outs CIR_IntType:$result, CIR_BoolType:$overflow);
+
+ let assemblyFormat = [{
+ `(` $kind `,` $lhs `,` $rhs `)` `:` type($lhs) `,`
+ `(` type($result) `,` type($overflow) `)`
+ attr-dict
+ }];
+
+ let builders = [
+ OpBuilder<(ins "cir::IntType":$resultTy,
+ "cir::BinOpOverflowKind":$kind,
+ "mlir::Value":$lhs,
+ "mlir::Value":$rhs), [{
+ auto overflowTy = cir::BoolType::get($_builder.getContext());
+ build($_builder, $_state, resultTy, overflowTy, kind, lhs, rhs);
+ }]>
+ ];
+
+ let extraLLVMLoweringPatternDecl = [{
+ static std::string getLLVMIntrinName(cir::BinOpOverflowKind opKind,
+ bool isSigned, unsigned width);
+
+ struct EncompassedTypeInfo {
+ bool sign;
+ unsigned width;
+ };
+
+ static EncompassedTypeInfo computeEncompassedTypeWidth(cir::IntType operandTy,
+ cir::IntType resultTy);
+ }];
+}
+
+
//===----------------------------------------------------------------------===//
// BinOp
//===----------------------------------------------------------------------===//
@@ -1882,6 +1958,13 @@ def CIR_GlobalLinkageKind : CIR_I32EnumAttr<
// properties of a global variable will be added over time as more of ClangIR
// is upstreamed.
+def CIR_TLSModel : CIR_I32EnumAttr<"TLS_Model", "TLS model", [
+ I32EnumAttrCase<"GeneralDynamic", 0, "tls_dyn">,
+ I32EnumAttrCase<"LocalDynamic", 1, "tls_local_dyn">,
+ I32EnumAttrCase<"InitialExec", 2, "tls_init_exec">,
+ I32EnumAttrCase<"LocalExec", 3, "tls_local_exec">
+]>;
+
def CIR_GlobalOp : CIR_Op<"global", [
DeclareOpInterfaceMethods<RegionBranchOpInterface>,
DeclareOpInterfaceMethods<CIRGlobalValueInterface>,
@@ -1910,6 +1993,7 @@ def CIR_GlobalOp : CIR_Op<"global", [
OptionalAttr<StrAttr>:$sym_visibility,
TypeAttr:$sym_type,
CIR_GlobalLinkageKind:$linkage,
+ OptionalAttr<CIR_TLSModel>:$tls_model,
OptionalAttr<AnyAttr>:$initial_value,
UnitAttr:$comdat,
UnitAttr:$constant,
@@ -1925,6 +2009,7 @@ def CIR_GlobalOp : CIR_Op<"global", [
(`constant` $constant^)?
$linkage
(`comdat` $comdat^)?
+ ($tls_model^)?
(`dso_local` $dso_local^)?
$sym_name
custom<GlobalOpTypeAndInitialValue>($sym_type, $initial_value,
@@ -1988,16 +2073,22 @@ def CIR_GetGlobalOp : CIR_Op<"get_global", [
undefined. The resulting type must always be a `!cir.ptr<...>` type with the
same address space as the global variable.
+ Addresses of thread local globals can only be retrieved if this operation
+ is marked `thread_local`, which indicates the address isn't constant.
+
Example:
```mlir
%x = cir.get_global @gv : !cir.ptr<i32>
+ ...
+ %y = cir.get_global thread_local @tls_gv : !cir.ptr<i32>
```
}];
- let arguments = (ins FlatSymbolRefAttr:$name);
+ let arguments = (ins FlatSymbolRefAttr:$name, UnitAttr:$tls);
let results = (outs Res<CIR_PointerType, "", []>:$addr);
let assemblyFormat = [{
+ (`thread_local` $tls^)?
$name `:` qualified(type($addr)) attr-dict
}];
}
diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp
index d9b9e3b877b50..8ac6bc2bdb80d 100644
--- a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp
@@ -58,6 +58,45 @@ static RValue emitBuiltinBitOp(CIRGenFunction &cgf, const CallExpr *e,
return RValue::get(result);
}
+namespace {
+struct WidthAndSignedness {
+ unsigned width;
+ bool isSigned;
+};
+} // namespace
+
+static WidthAndSignedness
+getIntegerWidthAndSignedness(const clang::ASTContext &astContext,
+ const clang::QualType type) {
+ assert(type->isIntegerType() && "Given type is not an integer.");
+ unsigned width = type->isBooleanType() ? 1
+ : type->isBitIntType() ? astContext.getIntWidth(type)
+ : astContext.getTypeInfo(type).Width;
+ bool isSigned = type->isSignedIntegerType();
+ return {width, isSigned};
+}
+
+// Given one or more integer types, this function produces an integer type that
+// encompasses them: any value in one of the given types could be expressed in
+// the encompassing type.
+static struct WidthAndSignedness
+EncompassingIntegerType(ArrayRef<struct WidthAndSignedness> types) {
+ assert(types.size() > 0 && "Empty list of types.");
+
+ // If any of the given types is signed, we must return a signed type.
+ bool isSigned = llvm::any_of(types, [](const auto &t) { return t.isSigned; });
+
+ // The encompassing type must have a width greater than or equal to the width
+ // of the specified types. Additionally, if the encompassing type is signed,
+ // its width must be strictly greater than the width of any unsigned types
+ // given.
+ unsigned width = 0;
+ for (const auto &type : types)
+ width = std::max(width, type.width + (isSigned && !type.isSigned));
+
+ return {width, isSigned};
+}
+
RValue CIRGenFunction::emitRotate(const CallExpr *e, bool isRotateLeft) {
mlir::Value input = emitScalarExpr(e->getArg(0));
mlir::Value amount = emitScalarExpr(e->getArg(1));
@@ -491,6 +530,154 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl &gd, unsigned builtinID,
cir::PrefetchOp::create(builder, loc, address, locality, isWrite);
return RValue::get(nullptr);
}
+ case Builtin::BI__builtin_add_overflow:
+ case Builtin::BI__builtin_sub_overflow:
+ case Builtin::BI__builtin_mul_overflow: {
+ const clang::Expr *LeftArg = e->getArg(0);
+ const clang::Expr *RightArg = e->getArg(1);
+ const clang::Expr *ResultArg = e->getArg(2);
+
+ clang::QualType ResultQTy =
+ ResultArg->getType()->castAs<clang::PointerType>()->getPointeeType();
+
+ WidthAndSignedness LeftInfo =
+ getIntegerWidthAndSignedness(cgm.getASTContext(), LeftArg->getType());
+ WidthAndSignedness RightInfo =
+ getIntegerWidthAndSignedness(cgm.getASTContext(), RightArg->getType());
+ WidthAndSignedness ResultInfo =
+ getIntegerWidthAndSignedness(cgm.getASTContext(), ResultQTy);
+
+ // Note we compute the encompassing type with the consideration to the
+ // result type, so later in LLVM lowering we don't get redundant integral
+ // extension casts.
+ WidthAndSignedness EncompassingInfo =
+ EncompassingIntegerType({LeftInfo, RightInfo, ResultInfo});
+
+ auto EncompassingCIRTy = cir::IntType::get(
+ &getMLIRContext(), EncompassingInfo.width, EncompassingInfo.isSigned);
+ auto ResultCIRTy = mlir::cast<cir::IntType>(cgm.convertType(ResultQTy));
+
+ mlir::Value Left = emitScalarExpr(LeftArg);
+ mlir::Value Right = emitScalarExpr(RightArg);
+ Address ResultPtr = emitPointerWithAlignment(ResultArg);
+
+ // Extend each operand to the encompassing type, if necessary.
+ if (Left.getType() != EncompassingCIRTy)
+ Left =
+ builder.createCast(cir::CastKind::integral, Left, EncompassingCIRTy);
+ if (Right.getType() != EncompassingCIRTy)
+ Right =
+ builder.createCast(cir::CastKind::integral, Right, EncompassingCIRTy);
+
+ // Perform the operation on the extended values.
+ cir::BinOpOverflowKind OpKind;
+ switch (builtinID) {
+ default:
+ llvm_unreachable("Unknown overflow builtin id.");
+ case Builtin::BI__builtin_add_overflow:
+ OpKind = cir::BinOpOverflowKind::Add;
+ break;
+ case Builtin::BI__builtin_sub_overflow:
+ OpKind = cir::BinOpOverflowKind::Sub;
+ break;
+ case Builtin::BI__builtin_mul_overflow:
+ OpKind = cir::BinOpOverflowKind::Mul;
+ break;
+ }
+
+ auto Loc = getLoc(e->getSourceRange());
+ cir::BinOpOverflowOp ArithOp =
+ cir::BinOpOverflowOp::create(builder, Loc, ResultCIRTy, OpKind, Left, Right);
+
+ // Here is a slight difference from the original clang CodeGen:
+ // - In the original clang CodeGen, the checked arithmetic result is
+ // first computed as a value of the encompassing type, and then it is
+ // truncated to the actual result type with a second overflow checking.
+ // - In CIRGen, the checked arithmetic operation directly produce the
+ // checked arithmetic result in its expected type.
+ //
+ // So we don't need a truncation and a second overflow checking here.
+
+ // Finally, store the result using the pointer.
+ bool isVolatile =
+ ResultArg->getType()->getPointeeType().isVolatileQualified();
+ builder.createStore(Loc, emitToMemory(ArithOp.getResult(), ResultQTy),
+ ResultPtr, isVolatile);
+
+ return RValue::get(ArithOp.getOverflow());
+ }
+
+ case Builtin::BI__builtin_uadd_overflow:
+ case Builtin::BI__builtin_uaddl_overflow:
+ case Builtin::BI__builtin_uaddll_overflow:
+ case Builtin::BI__builtin_usub_overflow:
+ case Builtin::BI__builtin_usubl_overflow:
+ case Builtin::BI__builtin_usubll_overflow:
+ case Builtin::BI__builtin_umul_overflow:
+ case Builtin::BI__builtin_umull_overflow:
+ case Builtin::BI__builtin_umulll_overflow:
+ case Builtin::BI__builtin_sadd_overflow:
+ case Builtin::BI__builtin_saddl_overflow:
+ case Builtin::BI__builtin_saddll_overflow:
+ case Builtin::BI__builtin_ssub_overflow:
+ case Builtin::BI__builtin_ssubl_overflow:
+ case Builtin::BI__builtin_ssubll_overflow:
+ case Builtin::BI__builtin_smul_overflow:
+ case Builtin::BI__builtin_smull_overflow:
+ case Builtin::BI__builtin_smulll_overflow: {
+ // Scalarize our inputs.
+ mlir::Value X = emitScalarExpr(e->getArg(0));
+ mlir::Value Y = emitScalarExpr(e->getArg(1));
+
+ const clang::Expr *ResultArg = e->getArg(2);
+ Address ResultPtr = emitPointerWithAlignment(ResultArg);
+
+ // Decide which of the arithmetic operation we are lowering to:
+ cir::BinOpOverflowKind ArithKind;
+ switch (builtinID) {
+ default:
+ llvm_unreachable("Unknown overflow builtin id.");
+ case Builtin::BI__builtin_uadd_overflow:
+ case Builtin::BI__builtin_uaddl_overflow:
+ case Builtin::BI__builtin_uaddll_overflow:
+ case Builtin::BI__builtin_sadd_overflow:
+ case Builtin::BI__builtin_saddl_overflow:
+ case Builtin::BI__builtin_saddll_overflow:
+ ArithKind = cir::BinOpOverflowKind::Add;
+ break;
+ case Builtin::BI__builtin_usub_overflow:
+ case Builtin::BI__builtin_usubl_overflow:
+ case Builtin::BI__builtin_usubll_overflow:
+ case Builtin::BI__builtin_ssub_overflow:
+ case Builtin::BI__builtin_ssubl_overflow:
+ case Builtin::BI__builtin_ssubll_overflow:
+ ArithKind = cir::BinOpOverflowKind::Sub;
+ break;
+ case Builtin::BI__builtin_umul_overflow:
+ case Builtin::BI__builtin_umull_overflow:
+ case Builtin::BI__builtin_umulll_overflow:
+ case Builtin::BI__builtin_smul_overflow:
+ case Builtin::BI__builtin_smull_overflow:
+ case Builtin::BI__builtin_smulll_overflow:
+ ArithKind = cir::BinOpOverflowKind::Mul;
+ break;
+ }
+
+ clang::QualType ResultQTy =
+ ResultArg->getType()->castAs<clang::PointerType>()->getPointeeType();
+ auto ResultCIRTy = mlir::cast<cir::IntType>(cgm.convertType(ResultQTy));
+
+ auto Loc = getLoc(e->getSourceRange());
+ cir::BinOpOverflowOp ArithOp =
+ cir::BinOpOverflowOp::create(builder, Loc, ResultCIRTy, ArithKind, X, Y);
+
+ bool isVolatile =
+ ResultArg->getType()->getPointeeType().isVolatileQualified();
+ builder.createStore(Loc, emitToMemory(ArithOp.getResult(), ResultQTy),
+ ResultPtr, isVolatile);
+
+ return RValue::get(ArithOp.getOverflow());
+ }
}
// If this is an alias for a lib function (e.g. __builtin_sin), emit
diff --git a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp
index aeea0efeb77c3..27e9c7bc53fc4 100644
--- a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp
@@ -361,7 +361,8 @@ CIRGenModule::getOrCreateStaticVarDecl(const VarDecl &d,
if (supportsCOMDAT() && gv.isWeakForLinker())
gv.setComdat(true);
- assert(!cir::MissingFeatures::opGlobalThreadLocal());
+ if (d.getTLSKind())
+ llvm_unreachable("TLS mode is NYI");
setGVProperties(gv, &d);
diff --git a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
index 5ccb431e626ae..e2869bcba3b79 100644
--- a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp
@@ -277,7 +277,6 @@ static LValue emitGlobalVarDeclLValue(CIRGenFunction &cgf, const Expr *e,
QualType t = e->getType();
// If it's thread_local, emit a call to its wrapper function instead.
- assert(!cir::MissingFeatures::opGlobalThreadLocal());
if (vd->getTLSKind() == VarDecl::TLS_Dynamic)
cgf.cgm.errorNYI(e->getSourceRange(),
"emitGlobalVarDeclLValue: thread_local variable");
@@ -312,7 +311,8 @@ static LValue emitGlobalVarDeclLValue(CIRGenFunction &cgf, const Expr *e,
void CIRGenFunction::emitStoreOfScalar(mlir::Value value, Address addr,
bool isVolatile, QualType ty,
bool isInit, bool isNontemporal) {
- assert(!cir::MissingFeatures::opLoadStoreThreadLocal());
+ // Traditional LLVM codegen handles thread local separately, CIR handles
+ // as part of getAddrOfGlobalVar (GetGlobalOp).
if (const auto *clangVecTy = ty->getAs<clang::VectorType>()) {
// Boolean vectors use `iN` as storage type.
@@ -556,7 +556,8 @@ void CIRGenFunction::emitStoreOfScalar(mlir::Value value, LValue lvalue,
mlir::Value CIRGenFunction::emitLoadOfScalar(Address addr, bool isVolatile,
QualType ty, SourceLocation loc,
LValueBaseInfo baseInfo) {
- assert(!cir::MissingFeatures::opLoadStoreThreadLocal());
+ // Traditional LLVM codegen handles thread local separately, CIR handles
+ // as part of getAddrOfGlobalVar (GetGlobalOp).
mlir::Type eltTy = addr.getElementType();
if (const auto *clangVecTy = ty->getAs<clang::VectorType>()) {
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
index 9f9b2db4771df..8426d5dae110f 100644
--- a/clang/lib/CIR/CodeGen/CIRGenModule.cpp
+++ b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
@@ -679,8 +679,11 @@ CIRGenModule::getOrCreateCIRGlobal(StringRef mangledName, mlir::Type ty,
setLinkageForGV(gv, d);
- if (d->getTLSKind())
- errorNYI(d->getSourceRange(), "thread local global variable");
+ if (d->getTLSKind()) {
+ if (d->getTLSKind() == VarDecl::TLS_Dynamic)
+ errorNYI(d->getSourceRange(), "TLS dynamic");
+ setTLSMode(gv, *d);
+ }
setGVProperties(gv, d);
@@ -735,12 +738,13 @@ mlir::Value CIRGenModule::getAddrOfGlobalVar(const VarDecl *d, mlir::Type ty,
if (!ty)
ty = getTypes().convertTypeForMem(astTy);
- assert(!cir::MissingFeatures::opGlobalThreadLocal());
-
+ bool tlsAccess = d->getTLSKind() != VarDecl::TLS_None;
cir::GlobalOp g = getOrCreateCIRGlobal(d, ty, isForDefinition);
mlir::Type ptrTy = builder.getPointerTo(g.getSymType());
- return cir::GetGlobalOp::create(builder, getLoc(d->getSourceRange()), ptrTy,
- g.getSymName());
+ auto getGlobalOp = cir::GetGlobalOp::create(
+ builder, getLoc(d->getSourceRange()), ptrTy, g.getSymNameAttr(),
+ tlsAccess);
+ return getGlobalOp.getAddr();
}
cir::GlobalViewAttr CIRGenModule::getAddrOfGlobalVarAttr(const VarDecl *d) {
@@ -1898,6 +1902,35 @@ void CIRGenModule::setGVPropertiesAux(mlir::Operation *op,
assert(!cir::MissingFeatures::opGlobalPartition());
}
+cir::TLS_Model CIRGenModule::GetDefaultCIRTLSModel() const {
+ switch (getCodeGenOpts().getDefaultTLSModel()) {
+ case CodeGenOptions::GeneralDynamicTLSModel:
+ return cir::TLS_Model::GeneralDynamic;
+ case CodeGenOptions::LocalDynamicTLSModel:
+ return cir::TLS_Model::LocalDynamic;
+ case CodeGenOptions::InitialExecTLSModel:
+ return cir::TLS_Model::InitialExec;
+ case CodeGenOptions::LocalExecTLSModel:
+ return cir::TLS_Model::LocalExec;
+ }
+ llvm_unreachable("Invalid TLS model!");
+}
+
+void CIRGenModule::setTLSMode(mlir::Operation *op, const VarDecl &d) const {
+ assert(d.getTLSKind() && "setting TLS mode on non-TLS var!");
+
+ auto tlm = GetDefaultCIRTLSModel();
+
+ // Override the TLS model if it is explicitly specified.
+ if (d.getAttr<TLSModelAttr>()) {
+ llvm_unreachable("NYI");
+ }
+
+ auto global = dyn_cast<cir::GlobalOp>(op);
+ assert(global && "NYI for other operations");
+ global.setTlsModel(tlm);
+}
+
void CIRGenModule::setFunctionAttributes(GlobalD...
[truncated]
|
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
4 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This commit adds full support for thread-local storage variables in ClangIR, including code generation, lowering to LLVM IR, and comprehensive testing.
Changes include:
Known limitations (matching incubator):
This fixes issue #153270