Skip to content

Commit 174fb2e

Browse files
seven-mileseven-mile
committed
use separate AddressSpaceAttr
1 parent 1033535 commit 174fb2e

File tree

5 files changed

+236
-142
lines changed

5 files changed

+236
-142
lines changed

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

+4-7
Original file line numberDiff line numberDiff line change
@@ -77,14 +77,11 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
7777

7878
mlir::cir::PointerType
7979
getPointerTo(mlir::Type ty, clang::LangAS langAS = clang::LangAS::Default) {
80-
auto addrSpaceKind = mlir::cir::PointerType::getCIRASKindFromLangAS(langAS);
80+
mlir::cir::AddressSpaceAttr addrSpaceAttr;
81+
if (langAS != clang::LangAS::Default)
82+
addrSpaceAttr = mlir::cir::AddressSpaceAttr::get(getContext(), langAS);
8183

82-
std::optional<unsigned> targetAddrSpaceValue = std::nullopt;
83-
if (addrSpaceKind == mlir::cir::LangAddrSpace::target)
84-
targetAddrSpaceValue = clang::toTargetAddressSpace(langAS);
85-
86-
return mlir::cir::PointerType::get(getContext(), ty, addrSpaceKind,
87-
targetAddrSpaceValue);
84+
return mlir::cir::PointerType::get(getContext(), ty, addrSpaceAttr);
8885
}
8986

9087
mlir::cir::PointerType

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

+158
Original file line numberDiff line numberDiff line change
@@ -617,6 +617,164 @@ def DynamicCastInfoAttr
617617
}];
618618
}
619619

620+
//===----------------------------------------------------------------------===//
621+
// AddressSpaceAttr
622+
//===----------------------------------------------------------------------===//
623+
624+
// These keywords should always be sync with clang::LangAS
625+
def AS_OpenCLGlobal : I32EnumAttrCase<"opencl_global", 1>;
626+
def AS_OpenCLLocal : I32EnumAttrCase<"opencl_local", 2>;
627+
def AS_OpenCLConstant : I32EnumAttrCase<"opencl_constant", 3>;
628+
def AS_OpenCLPrivate : I32EnumAttrCase<"opencl_private", 4>;
629+
def AS_OpenCLGeneric : I32EnumAttrCase<"opencl_generic", 5>;
630+
def AS_OpenCLGlobalDevice : I32EnumAttrCase<"opencl_global_device", 6>;
631+
def AS_OpenCLGlobalHost : I32EnumAttrCase<"opencl_global_host", 7>;
632+
def AS_CUDADevice : I32EnumAttrCase<"cuda_device", 8>;
633+
def AS_CUDAConstant : I32EnumAttrCase<"cuda_constant", 9>;
634+
def AS_CUDAShared : I32EnumAttrCase<"cuda_shared", 10>;
635+
def AS_SYCLGlobal : I32EnumAttrCase<"sycl_global", 11>;
636+
def AS_SYCLGlobalDevice : I32EnumAttrCase<"sycl_global_device", 12>;
637+
def AS_SYCLGlobalHost : I32EnumAttrCase<"sycl_global_host", 13>;
638+
def AS_SYCLLocal : I32EnumAttrCase<"sycl_local", 14>;
639+
def AS_SYCLPrivate : I32EnumAttrCase<"sycl_private", 15>;
640+
def AS_Ptr32SPtr : I32EnumAttrCase<"ptr32_sptr", 16>;
641+
def AS_Ptr32UPtr : I32EnumAttrCase<"ptr32_uptr", 17>;
642+
def AS_Ptr64 : I32EnumAttrCase<"ptr64", 18>;
643+
def AS_HLSLGroupShared : I32EnumAttrCase<"hlsl_groupshared", 19>;
644+
def AS_WasmFuncref : I32EnumAttrCase<"wasm_funcref", 20>;
645+
def AS_Target : I32EnumAttrCase<"target", 21>;
646+
647+
def AddressSpaceAttr : CIR_Attr<"AddressSpace", "addrspace"> {
648+
649+
let summary = "Address space attribute for pointer types";
650+
let description = [{
651+
The address space attribute models `clang::LangAS` rather than the LLVM
652+
address space, which means it's not yet converted by the address space map
653+
to carry target-specific semantics.
654+
655+
The representation is one-to-one except for `LangAS::Default`, which
656+
corresponds to a null attribute instead.
657+
}];
658+
659+
let parameters = (ins "int64_t":$value);
660+
661+
let assemblyFormat = [{
662+
`<` $value `>`
663+
}];
664+
665+
let builders = [
666+
AttrBuilder<(ins "clang::LangAS":$langAS), [{
667+
assert(langAS != clang::LangAS::Default &&
668+
"Default address space is encoded as null attribute");
669+
return $_get($_ctxt, getValueFromLangAS(langAS).value());
670+
}]>
671+
];
672+
673+
let cppNamespace = "::mlir::cir";
674+
675+
// The following codes implement these conversions:
676+
// clang::LangAS -> int64_t <-> text-form CIR
677+
678+
// CIR_PointerType manipulates the parse- and stringify- methods to provide
679+
// simplified assembly format `custom<PointerAddrSpace>`.
680+
681+
list<I32EnumAttrCase> langASCases = [
682+
AS_OpenCLGlobal, AS_OpenCLLocal, AS_OpenCLConstant, AS_OpenCLPrivate,
683+
AS_OpenCLGeneric, AS_OpenCLGlobalDevice, AS_OpenCLGlobalHost,
684+
AS_CUDADevice, AS_CUDAConstant, AS_CUDAShared, AS_SYCLGlobal,
685+
AS_SYCLGlobalDevice, AS_SYCLGlobalHost, AS_SYCLLocal, AS_SYCLPrivate,
686+
AS_Ptr32SPtr, AS_Ptr32UPtr, AS_Ptr64, AS_HLSLGroupShared, AS_WasmFuncref
687+
];
688+
689+
I32EnumAttrCase targetASCase = AS_Target;
690+
691+
let extraClassDeclaration = [{
692+
static constexpr char kTargetKeyword[] = "}]#targetASCase.symbol#[{";
693+
static constexpr int64_t kFirstTargetASValue = }]#targetASCase.value#[{;
694+
695+
bool isLang() const;
696+
bool isTarget() const;
697+
unsigned getTargetValue() const;
698+
699+
static std::optional<int64_t> parseValueFromString(llvm::StringRef s);
700+
static std::optional<int64_t> getValueFromLangAS(clang::LangAS v);
701+
static std::optional<llvm::StringRef> stringifyValue(int64_t v);
702+
}];
703+
704+
let extraClassDefinition = [{
705+
bool $cppClass::isLang() const {
706+
return !isTarget();
707+
}
708+
709+
bool $cppClass::isTarget() const {
710+
return getValue() >= kFirstTargetASValue;
711+
}
712+
713+
unsigned $cppClass::getTargetValue() const {
714+
assert(isTarget() && "Not a target address space");
715+
return getValue() - kFirstTargetASValue;
716+
}
717+
718+
std::optional<int64_t>
719+
$cppClass::parseValueFromString(llvm::StringRef str) {
720+
return llvm::StringSwitch<::std::optional<int64_t>>(str)
721+
}]
722+
#
723+
!interleave(
724+
!foreach(case, langASCases,
725+
".Case(\""#case.symbol# "\", "#case.value # ")\n"
726+
),
727+
"\n"
728+
)
729+
#
730+
[{
731+
// Target address spaces are not parsed here
732+
.Default(std::nullopt);
733+
}
734+
735+
std::optional<llvm::StringRef>
736+
$cppClass::stringifyValue(int64_t value) {
737+
switch (value) {
738+
}]
739+
#
740+
!interleave(
741+
!foreach(case, langASCases,
742+
"case "#case.value
743+
# ": return \""#case.symbol # "\";" ),
744+
"\n"
745+
)
746+
#
747+
[{
748+
default:
749+
// Target address spaces are not processed here
750+
return std::nullopt;
751+
}
752+
}
753+
754+
std::optional<int64_t>
755+
$cppClass::getValueFromLangAS(clang::LangAS langAS) {
756+
switch (langAS) {
757+
}]
758+
#
759+
!interleave(
760+
!foreach(case, langASCases,
761+
"case clang::LangAS::"#case.symbol
762+
# ": return "#case.value # ";" ),
763+
"\n"
764+
)
765+
#
766+
[{
767+
case clang::LangAS::Default:
768+
// Default address space should be encoded as a null attribute.
769+
return std::nullopt;
770+
default:
771+
// Target address space offset arithmetics
772+
return clang::toTargetAddressSpace(langAS) + kFirstTargetASValue;
773+
}
774+
}
775+
}];
776+
}
777+
620778
//===----------------------------------------------------------------------===//
621779
// AST Wrappers
622780
//===----------------------------------------------------------------------===//

‎clang/include/clang/CIR/Dialect/IR/CIRTypes.td

+13-116
Original file line numberDiff line numberDiff line change
@@ -200,63 +200,6 @@ def CIR_AnyIntOrFloat: AnyTypeOf<[CIR_AnyFloat, CIR_IntType]>;
200200
// PointerType
201201
//===----------------------------------------------------------------------===//
202202

203-
def AS_Default : I32EnumAttrCase<"Default", 1>;
204-
def AS_OpenCLGlobal : I32EnumAttrCase<"opencl_global", 2>;
205-
def AS_OpenCLLocal : I32EnumAttrCase<"opencl_local", 3>;
206-
def AS_OpenCLConstant : I32EnumAttrCase<"opencl_constant", 4>;
207-
def AS_OpenCLPrivate : I32EnumAttrCase<"opencl_private", 5>;
208-
def AS_OpenCLGeneric : I32EnumAttrCase<"opencl_generic", 6>;
209-
def AS_OpenCLGlobalDevice : I32EnumAttrCase<"opencl_global_device", 7>;
210-
def AS_OpenCLGlobalHost : I32EnumAttrCase<"opencl_global_host", 8>;
211-
def AS_CUDADevice : I32EnumAttrCase<"cuda_device", 9>;
212-
def AS_CUDAConstant : I32EnumAttrCase<"cuda_constant", 10>;
213-
def AS_CUDAShared : I32EnumAttrCase<"cuda_shared", 11>;
214-
def AS_SYCLGlobal : I32EnumAttrCase<"sycl_global", 12>;
215-
def AS_SYCLGlobalDevice : I32EnumAttrCase<"sycl_global_device", 13>;
216-
def AS_SYCLGlobalHost : I32EnumAttrCase<"sycl_global_host", 14>;
217-
def AS_SYCLLocal : I32EnumAttrCase<"sycl_local", 15>;
218-
def AS_SYCLPrivate : I32EnumAttrCase<"sycl_private", 16>;
219-
def AS_Ptr32SPtr : I32EnumAttrCase<"ptr32_sptr", 17>;
220-
def AS_Ptr32UPtr : I32EnumAttrCase<"ptr32_uptr", 18>;
221-
def AS_Ptr64 : I32EnumAttrCase<"ptr64", 19>;
222-
def AS_HLSLGroupShared : I32EnumAttrCase<"hlsl_groupshared", 20>;
223-
def AS_WasmFuncref : I32EnumAttrCase<"wasm_funcref", 21>;
224-
def AS_Target : I32EnumAttrCase<"target", 22>;
225-
226-
// This enum must be sync with `clang::LangAS`
227-
def LangAddrSpace : I32EnumAttr<
228-
"LangAddrSpace",
229-
"language address space",
230-
[
231-
AS_Default, AS_OpenCLGlobal, AS_OpenCLLocal, AS_OpenCLConstant,
232-
AS_OpenCLPrivate, AS_OpenCLGeneric, AS_OpenCLGlobalDevice,
233-
AS_OpenCLGlobalHost, AS_CUDADevice, AS_CUDAConstant, AS_CUDAShared,
234-
AS_SYCLGlobal, AS_SYCLGlobalDevice, AS_SYCLGlobalHost, AS_SYCLLocal,
235-
AS_SYCLPrivate, AS_Ptr32SPtr, AS_Ptr32UPtr, AS_Ptr64, AS_HLSLGroupShared,
236-
AS_WasmFuncref, AS_Target
237-
]> {
238-
let cppNamespace = "::mlir::cir";
239-
240-
let genSpecializedAttr = 0;
241-
}
242-
243-
// Shorthands for long types
244-
def LangAddrSpaceParam : DefaultValuedParameter<
245-
"::mlir::cir::LangAddrSpace",
246-
"::mlir::cir::LangAddrSpace::Default"
247-
>;
248-
def LangAddrSpaceArg : CArg<
249-
"::mlir::cir::LangAddrSpace",
250-
"::mlir::cir::LangAddrSpace::Default"
251-
>;
252-
def TargetAddrSpaceParam : OptionalParameter<
253-
"std::optional<unsigned>"
254-
>;
255-
def TargetAddrSpaceArg : CArg<
256-
"std::optional<unsigned>",
257-
"std::nullopt"
258-
>;
259-
260203
def CIR_PointerType : CIR_Type<"Pointer", "ptr",
261204
[DeclareTypeInterfaceMethods<DataLayoutTypeInterface>]> {
262205

@@ -272,82 +215,36 @@ def CIR_PointerType : CIR_Type<"Pointer", "ptr",
272215

273216
let parameters = (ins
274217
"mlir::Type":$pointee,
275-
LangAddrSpaceParam:$addrSpaceKind,
276-
TargetAddrSpaceParam:$targetAddrSpaceValue
218+
OptionalParameter<"mlir::Attribute">:$addrSpace
277219
);
278220

221+
let assemblyFormat = [{
222+
`<` $pointee ( `,` `addrspace` `(`
223+
custom<PointerAddrSpace>($addrSpace)^
224+
`)` )? `>`
225+
}];
226+
227+
let genVerifyDecl = 1;
228+
279229
let skipDefaultBuilders = 1;
280230

281231
let builders = [
282232
TypeBuilderWithInferredContext<(ins
283233
"mlir::Type":$pointee,
284-
LangAddrSpaceArg:$addrSpaceKind,
285-
TargetAddrSpaceArg:$targetAddrSpaceValue), [{
286-
return $_get(
287-
pointee.getContext(), pointee, addrSpaceKind, targetAddrSpaceValue);
234+
CArg<"mlir::Attribute", "{}">:$addrSpace), [{
235+
return $_get(pointee.getContext(), pointee, addrSpace);
288236
}]>,
289237
TypeBuilder<(ins
290238
"mlir::Type":$pointee,
291-
LangAddrSpaceArg:$addrSpaceKind,
292-
TargetAddrSpaceArg:$targetAddrSpaceValue), [{
293-
return $_get($_ctxt, pointee, addrSpaceKind, targetAddrSpaceValue);
239+
CArg<"mlir::Attribute", "{}">:$addrSpace), [{
240+
return $_get($_ctxt, pointee, addrSpace);
294241
}]>
295242
];
296243

297-
let assemblyFormat = [{
298-
`<` $pointee ( `,` `addrspace` `(`
299-
$addrSpaceKind^
300-
(`<` $targetAddrSpaceValue^ `>`)?
301-
`)` )? `>`
302-
}];
303-
304-
let genVerifyDecl = 1;
305-
306-
// AS_Target should be excluded in codegen
307-
list<I32EnumAttrCase> langASCases =
308-
LangAddrSpace.enumerants[0...!sub(!size(LangAddrSpace.enumerants), 2)];
309-
310244
let extraClassDeclaration = [{
311245
bool isVoidPtr() const {
312246
return getPointee().isa<mlir::cir::VoidType>();
313247
}
314-
315-
static LangAddrSpace getCIRASKindFromLangAS(clang::LangAS langAS) {
316-
switch (langAS) {
317-
}]
318-
#
319-
!interleave(
320-
!foreach(case, langASCases, "case clang::LangAS::"#case.symbol
321-
# ": return LangAddrSpace::"#case.symbol # ";" ),
322-
"\n"
323-
)
324-
#
325-
[{
326-
default:
327-
return LangAddrSpace::target;
328-
}
329-
}
330-
331-
clang::LangAS getLangAS() {
332-
auto kind = getAddrSpaceKind();
333-
auto targetValue = getTargetAddrSpaceValue();
334-
switch (kind) {
335-
}]
336-
#
337-
!interleave(
338-
!foreach(case, langASCases, "case LangAddrSpace::"#case.symbol
339-
# ": return clang::LangAS::"#case.symbol # ";" ),
340-
"\n"
341-
)
342-
#
343-
[{
344-
default: {
345-
assert(kind == LangAddrSpace::target &&
346-
targetValue.has_value() && "unexpected address space kind");
347-
return clang::getLangASFromTargetAS(*targetValue);
348-
}
349-
}
350-
}
351248
}];
352249
}
353250

0 commit comments

Comments
 (0)