[llvm] [AArch64][Bitcode] Use target memory for SME state (PR #205829)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Jun 25 07:30:37 PDT 2026
https://github.com/CarolineConcatto created https://github.com/llvm/llvm-project/pull/205829
Model AArch64 ZA and ZT0 intrinsic state using target_mem instead of inaccessiblemem.
Bump the bitcode memory-attribute encoding and upgrade old AArch64 bitcode so prior inaccessiblemem effects are preserved on the new target memory locations. Non-AArch64 bitcode keeps the old interpretation.
>From 7d6822b4fc8d417abcedb368ee1feb3df6e3674b Mon Sep 17 00:00:00 2001
From: CarolineConcatto <caroline.concatto at arm.com>
Date: Thu, 25 Jun 2026 14:20:02 +0000
Subject: [PATCH 1/2] [AArch64][LICM] Pre-commit test for SME-FP8 loop
---
.../Transforms/LICM/AArch64/sme-fp8-hoits.ll | 52 +++++++++++++++++++
1 file changed, 52 insertions(+)
create mode 100644 llvm/test/Transforms/LICM/AArch64/sme-fp8-hoits.ll
diff --git a/llvm/test/Transforms/LICM/AArch64/sme-fp8-hoits.ll b/llvm/test/Transforms/LICM/AArch64/sme-fp8-hoits.ll
new file mode 100644
index 0000000000000..85f079fc135c3
--- /dev/null
+++ b/llvm/test/Transforms/LICM/AArch64/sme-fp8-hoits.ll
@@ -0,0 +1,52 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
+; RUN: opt -S -passes=licm < %s | FileCheck %s
+
+target triple = "aarch64-unknown-linux-gnu"
+
+;; The set.fprm should be hoisted once ZA does not use the same
+;; memory location as FPMR.
+define void @fp8_fmopa_loop(ptr %lhs, ptr %rhs, i64 %fpmr, i64 %n) {
+; CHECK-LABEL: define void @fp8_fmopa_loop(
+; CHECK-SAME: ptr [[LHS:%.*]], ptr [[RHS:%.*]], i64 [[FPMR:%.*]], i64 [[N:%.*]]) {
+; CHECK-NEXT: [[ENTRY:.*]]:
+; CHECK-NEXT: [[PTRUE:%.*]] = call <vscale x 16 x i1> @llvm.aarch64.sve.ptrue.nxv16i1(i32 31)
+; CHECK-NEXT: [[LHS_LOAD:%.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.ld1.nxv16i8.p0(<vscale x 16 x i1> [[PTRUE]], ptr [[LHS]])
+; CHECK-NEXT: [[RHS_LOAD:%.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.ld1.nxv16i8.p0(<vscale x 16 x i1> [[PTRUE]], ptr [[RHS]])
+; CHECK-NEXT: br label %[[LOOP:.*]]
+; CHECK: [[LOOP]]:
+; CHECK-NEXT: [[IV:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
+; CHECK-NEXT: call void @llvm.aarch64.set.fpmr(i64 [[FPMR]])
+; CHECK-NEXT: call void @llvm.aarch64.sme.fp8.fmopa.za32(i32 0, <vscale x 16 x i1> [[PTRUE]], <vscale x 16 x i1> [[PTRUE]], <vscale x 16 x i8> [[LHS_LOAD]], <vscale x 16 x i8> [[RHS_LOAD]])
+; CHECK-NEXT: [[IV_NEXT]] = add nuw i64 [[IV]], 1
+; CHECK-NEXT: [[COND:%.*]] = icmp ult i64 [[IV_NEXT]], [[N]]
+; CHECK-NEXT: br i1 [[COND]], label %[[LOOP]], label %[[EXIT:.*]]
+; CHECK: [[EXIT]]:
+; CHECK-NEXT: ret void
+;
+entry:
+ br label %loop
+
+loop:
+ %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop ]
+ %ptrue = call <vscale x 16 x i1> @llvm.aarch64.sve.ptrue.nxv16i1(i32 31)
+ %lhs.load = call <vscale x 16 x i8> @llvm.aarch64.sve.ld1.nxv16i8(<vscale x 16 x i1> %ptrue, ptr %lhs)
+ %rhs.load = call <vscale x 16 x i8> @llvm.aarch64.sve.ld1.nxv16i8(<vscale x 16 x i1> %ptrue, ptr %rhs)
+ call void @llvm.aarch64.set.fpmr(i64 %fpmr)
+ call void @llvm.aarch64.sme.fp8.fmopa.za32(i32 0, <vscale x 16 x i1> %ptrue, <vscale x 16 x i1> %ptrue, <vscale x 16 x i8> %lhs.load, <vscale x 16 x i8> %rhs.load)
+ %iv.next = add nuw i64 %iv, 1
+ %cond = icmp ult i64 %iv.next, %n
+ br i1 %cond, label %loop, label %exit
+
+exit:
+ ret void
+}
+
+declare <vscale x 16 x i1> @llvm.aarch64.sve.ptrue.nxv16i1(i32 immarg) #0
+declare <vscale x 16 x i8> @llvm.aarch64.sve.ld1.nxv16i8(<vscale x 16 x i1>, ptr) #1
+declare void @llvm.aarch64.set.fpmr(i64) #2
+declare void @llvm.aarch64.sme.fp8.fmopa.za32(i32 immarg, <vscale x 16 x i1>, <vscale x 16 x i1>, <vscale x 16 x i8>, <vscale x 16 x i8>) #3
+
+attributes #0 = { nocallback nofree nosync nounwind willreturn memory(none) }
+attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: read) }
+attributes #2 = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: write) }
+attributes #3 = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }
>From ae1c49a6615e21170986e4207ffd0537efbb9240 Mon Sep 17 00:00:00 2001
From: CarolineConcatto <caroline.concatto at arm.com>
Date: Wed, 17 Jun 2026 12:55:23 +0000
Subject: [PATCH 2/2] [AArch64][Bitcode] Use target memory for SME state
Model AArch64 ZA and ZT0 intrinsic state using target_mem instead of
inaccessiblemem.
Bump the bitcode memory-attribute encoding and upgrade old AArch64 bitcode
so prior inaccessiblemem effects are preserved on the new target memory
locations. Non-AArch64 bitcode keeps the old interpretation.
---
llvm/docs/LangRef.rst | 3 +-
llvm/include/llvm/IR/IntrinsicsAArch64.td | 4 +-
llvm/lib/Bitcode/Reader/BitcodeReader.cpp | 34 ++++++++++++++---
llvm/lib/Bitcode/Writer/BitcodeWriter.cpp | 2 +-
.../aarch64-memory-attribute-upgrade.bc | Bin 0 -> 2016 bytes
.../Inputs/x86-memory-attribute-upgrade.bc | Bin 0 -> 2096 bytes
.../aarch64-target-memory-attribute.ll | 36 ++++++++++++++++++
.../Transforms/LICM/AArch64/sme-fp8-hoits.ll | 2 +-
8 files changed, 70 insertions(+), 11 deletions(-)
create mode 100644 llvm/test/Bitcode/Inputs/aarch64-memory-attribute-upgrade.bc
create mode 100644 llvm/test/Bitcode/Inputs/x86-memory-attribute-upgrade.bc
create mode 100644 llvm/test/Bitcode/aarch64-target-memory-attribute.ll
diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst
index 287341d787b64..66dce0077d7de 100644
--- a/llvm/docs/LangRef.rst
+++ b/llvm/docs/LangRef.rst
@@ -2292,8 +2292,7 @@ For example:
- ``errnomem``: This refers to accesses to the ``errno`` variable.
- ``target_mem#`` : These refer to target specific state that cannot be
accessed by any other means. # is a number between 0 and 1 inclusive.
- Note: The target_mem locations are experimental and intended for internal
- testing only. They must not be used in production code.
+ Note: The target_mem locations are implemented in AArch64.
- The default access kind (specified without a location prefix) applies to
all locations that haven't been specified explicitly, including those that
diff --git a/llvm/include/llvm/IR/IntrinsicsAArch64.td b/llvm/include/llvm/IR/IntrinsicsAArch64.td
index 5ba1f4ba861d2..6078e1438ceee 100644
--- a/llvm/include/llvm/IR/IntrinsicsAArch64.td
+++ b/llvm/include/llvm/IR/IntrinsicsAArch64.td
@@ -734,8 +734,8 @@ def int_aarch64_neon_tbx4 : AdvSIMD_Tbx4_Intrinsic;
// Maps Memory locations to registers.
defvar FPMR = InaccessibleMem;
-defvar ZT0 = InaccessibleMem;
-defvar ZA = InaccessibleMem;
+defvar ZT0 = TargetMem0;
+defvar ZA = TargetMem1;
let TargetPrefix = "aarch64" in {
class FPENV_Get_Intrinsic
diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
index c913dd811a2e0..a5f59a795b4ce 100644
--- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -581,6 +581,7 @@ class BitcodeConstant final : public Value,
class BitcodeReader : public BitcodeReaderBase, public GVMaterializer {
LLVMContext &Context;
Module *TheModule = nullptr;
+ Triple BitcodeTargetTriple;
// Next offset to start scanning for lazy parsing of function bodies.
uint64_t NextUnreadBit = 0;
// Last function offset found in the VST.
@@ -705,7 +706,8 @@ class BitcodeReader : public BitcodeReaderBase, public GVMaterializer {
public:
BitcodeReader(BitstreamCursor Stream, StringRef Strtab,
- StringRef ProducerIdentification, LLVMContext &Context);
+ StringRef ProducerIdentification, LLVMContext &Context,
+ Triple BitcodeTargetTriple);
Error materializeForwardReferencedFunctions();
@@ -1063,8 +1065,9 @@ std::error_code llvm::errorToErrorCodeAndEmitErrors(LLVMContext &Ctx,
BitcodeReader::BitcodeReader(BitstreamCursor Stream, StringRef Strtab,
StringRef ProducerIdentification,
- LLVMContext &Context)
+ LLVMContext &Context, Triple TTriple)
: BitcodeReaderBase(std::move(Stream), Strtab), Context(Context),
+ BitcodeTargetTriple(TTriple),
ValueList(this->Stream.SizeInBytes(),
[this](unsigned ValID, BasicBlock *InsertBB) {
return materializeValue(ValID, InsertBB);
@@ -2469,12 +2472,24 @@ Error BitcodeReader::parseAttributeGroupBlock() {
MemoryEffects::argMemOnly(ArgMem) |
MemoryEffects::errnoMemOnly(OtherMem) |
MemoryEffects::otherMemOnly(OtherMem);
+ // Old versions dont have target memory location.
+ // It was represented as Inaccessible memory for AArch64.
+ if (BitcodeTargetTriple.isAArch64())
+ for (auto Loc : MemoryEffects::targetMemLocations())
+ ME = ME.getWithModRef(Loc, InaccessibleMem);
B.addMemoryAttr(ME);
} else {
// Construct the memory attribute directly from the encoded base
// on newer versions.
- B.addMemoryAttr(MemoryEffects::createFromIntValue(
- EncodedME & 0x00FFFFFFFFFFFFFFULL));
+ auto ME = MemoryEffects::createFromIntValue(
+ EncodedME & 0x00FFFFFFFFFFFFFFULL);
+ // Only from Version=2 onwards target memory location exist.
+ // It was represented as Inaccessible memory for AArch64.
+ if (Version == 1 && BitcodeTargetTriple.isAArch64())
+ for (auto Loc : MemoryEffects::targetMemLocations())
+ ME = ME.getWithModRef(
+ Loc, ME.getModRef(IRMemLocation::InaccessibleMem));
+ B.addMemoryAttr(ME);
}
} else if (Kind == Attribute::Captures)
B.addCapturesAttr(CaptureInfo::createFromIntValue(Record[++i]));
@@ -8700,10 +8715,19 @@ BitcodeModule::getModuleImpl(LLVMContext &Context, bool MaterializeAll,
return std::move(E);
}
+ // Some invalid bitcode files have multiple independent errors.
+ // IF/ELSE avoids printing failure in this preliminary scan.
+ Triple BitcodeTargetTriple;
+ BitstreamCursor TripleStream(Buffer);
+ if (Expected<std::string> TripleStr = readTriple(TripleStream))
+ BitcodeTargetTriple = Triple(*TripleStr);
+ else
+ consumeError(TripleStr.takeError());
+
if (Error JumpFailed = Stream.JumpToBit(ModuleBit))
return std::move(JumpFailed);
auto *R = new BitcodeReader(std::move(Stream), Strtab, ProducerIdentification,
- Context);
+ Context, BitcodeTargetTriple);
std::unique_ptr<Module> M =
std::make_unique<Module>(ModuleIdentifier, Context);
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
index f4857461ca58e..29b621eed2700 100644
--- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -1078,7 +1078,7 @@ void ModuleBitcodeWriter::writeAttributeGroupTable() {
Record.push_back(getAttrKindEncoding(Kind));
if (Kind == Attribute::Memory) {
// Version field for upgrading old memory effects.
- const uint64_t Version = 1;
+ const uint64_t Version = 2;
Record.push_back((Version << 56) | Attr.getValueAsInt());
} else {
Record.push_back(Attr.getValueAsInt());
diff --git a/llvm/test/Bitcode/Inputs/aarch64-memory-attribute-upgrade.bc b/llvm/test/Bitcode/Inputs/aarch64-memory-attribute-upgrade.bc
new file mode 100644
index 0000000000000000000000000000000000000000..26bc0339df518d246390722f70b9d117119b60c5
GIT binary patch
literal 2016
zcmah~e{34(8UEl5M-uWKX;}@;9X(>VLRy?%u$>$RBxBNusHsM>{NeqQIU9(*IWEQo
z|43GWVLrD*72QyTrc5$wHD%H^k;&Vv$*T<Kc+^3un at v-+Sr*jTNhT-u5_gK!NZWgO
z`)iYSI=+wZ<Gc6X_j#W8q07Cn)~-iLg%Il1a?Njk{iC0L?~B>59xgSXQdm{UtVQS}
z1wsduW~78OP4FS(P4Bx(4QJFktL=x1r1n*n#%OBzL2pd^y0Yutret$tvc&o=Asu&3
z at AvE8_kG+or9HIoJ>H-6e3m|R#B)BTHJYy}{UyzzW?Sd!Dcx;_)tb~;FL*DoAIx>0
z4#%}d>lAhE%T~X^cm`Yji{0V0x#@KJRUOk2DNVnZHlLbGHCWpadWS`5ALMi-*r5AW
z*W|~#^Dv}`i(b$EeXqHfR9)8BG at 6$c7MEIy&KVG*;OyadEB}N`TzJW&YjDZ8{)E0L
zZ&C4<Jgb?MZ_A)%O5S=!`At+m)8O*Lvu7X%0rQKKzApBxMh#!li$4x&$Z-Q1$rBy@
zMASo$-XO28XoPUTx|+Y5`pu``cohDk<&)nQBfoRB{PK^tf6?*$DD|V;Emz97g49j)
z212YHrhes-Z#r-Zke0!&UojPO|D4Y^AXI- at eeVEjKB3Vc#0X8_f}_Ast0qP-R_UN#
z;hc8!Nh#G8Bge<ck?gQ`6H$+JcsGVywOyuSfw_~TgPf{<EOEF at I7@D4ig1?4QjrjO
z1q$(qp%6I{BBEnrh!u_HLwGBVs~k1NQR_Q+$BSEai_DstzGr5Nf+@(oW1mmhSKPK)
z!ZDw4Bnf+YM<4Z(SNh45{bCr#m>5cnAs-pFkkMx<2s;`Rdo<#(K at 4Zb@ofC);~o6C
zf<IrtTO83_%F(qPU9OL-0=;ae7vs#bp#F2(Z7aEL+4?vq at fkNiP1rNiSKy`3C+&YC
z?0HH1hXFCvErvshNIyB|6C(yOG9w!Ae2sdHs3%@rOXKxUs><RmsDiaHs|8chWx8vo
zSL3GD3SFx*e^Z!(hI4%0-Elo(FMFH+U5HN{9V5rG=g#h?DH#FNcTCFy{lLtu6_~db
zCOKg<vm>Z4d_TdLC41iO1VEk_9W}Ro8kSP()_$l|9EE%|<b;I`XXD>m*Ws-Nyy3-9
zxu(Khm#J25yjNw`AOVljo=-Su6Ni%$pK{yEl4Gu5D at jnJqwJX-){v0ZFaX#s8vnY4
zw|vy2ih75oHaKd7rT*c?Lpr?9VOTz`s2^5v&5NILO`mNEbTQ7{t2S<#nN2gZXl8)H
z2j*9T>`(0TZs#0f%Oq^&?s;Gzik*NwJ>qCcG~T|Cw>hd>!4EsBhcoaNNkNR<Afc9?
zEJ#I0II;p%#*;2vMFQxYz*M<&afVsWF%_3-tw0Bx`#4;c`K2Jp2In>>E*r=ZkJvLK
zUX8)CH!})HN^)c*e#PAZaw-F2T95flU4jWxy;ES$$MwOp7dgDmQri{vwwKzKL*b2z
zdXuH9D^TnQor!2aIj#|n=U<+a?4ZLB-Fz7^By8z~qf9se%#5TxeQ*h+3yR9oZ^unf
z6u{%sO*JSG;s6(|FPt!lp%^)FgB-U2WrbN6pC|0|68~K3oR>N>kX!#M%lt)Q0`!&u
zz`{Y9ePQZJJqV)K7vyGn$|d57I#Y6up#KpIIg$PQqN`&L5=+RsopE<S_kntAQtA!7
z9B0ba#?2hP6gS<iGON`_89GSMWdfNkL!;?OLiqDEu5s(RMARZiLl9pa?i9n%R1xr;
z8B(@}pMgJ}g!#b!um$>zoahc^fm at jt+ln-~NiXFNK5)r40J!ey_ocRVAHMH}wxDWq
zb5QracsC!5%K*q-J0?OMvSzzO*Cl>d0qHw4lJdJ?0Q72=US;W;Ade5?rlLTv<ml3#
z(1e15+68ies~A2oy+^p}6CUWj2Td%2-0Yxk at SYN3KWYJO-i2sF;S}Bg{esqfR24?>
zh86YGH1&wZ+Y8`$2z{#C^Fp%h03@%22 at uYigaZsAErAsx!LnzcO&Vq0GXLLtm_-Qe
z6<M+FND}>;Fr at 7<<?m&eN9fz||91 at L7l_QD96J&iiS!H%34MKmk&%Jk!9Y(qAo&0H
z?r3-*68P_*hTa+qSX+;A$GD3F5w@@Iq>bnO?Z?~udU=1a{kWeOT2BgXt$v#jY;Wg}
z_qDb6!T~`D_w}D>YZ)9Ex;*xu#ihWdx5DEsLL?F%=)D{Xv|J8d3=951OZ51$!9h9y
Fe*qiJ){g)H
literal 0
HcmV?d00001
diff --git a/llvm/test/Bitcode/Inputs/x86-memory-attribute-upgrade.bc b/llvm/test/Bitcode/Inputs/x86-memory-attribute-upgrade.bc
new file mode 100644
index 0000000000000000000000000000000000000000..d40ceb9b2e459ee0e70e6f5cc1808ad4cd1a89fb
GIT binary patch
literal 2096
zcmah~e at q+a8UAd8&nf0RC!@s<cbB_BD^Dfa%>;7Bwq|op<fxhEWRXU-Zg9pBs8V8#
z1BPyu&3RmsS(Q7X3~8xk)T-+Kb0#M72kJ1#s7o!BWnGq~2-)Swl8GiBNv24Pw7qBg
z-!|=Zem{TTecyZU`#jJ4UWd4_-dcxHH9{z8=9|9z+Q%RM^q;feYsfdfqH|Ou&WzBX
zbqLkyIi!a at jqoE9jqm#MRi}&=hw~S at r1`~alZ~nRc`$B1q3^ibm~5&~=Gl-vY~iof
zg+i8hyFcxiH1FT{ju1-vzfA8x>^~bf+qi4`P~Nn^$>}{gY57d&a3uYXbAfa0`*Yrt
zk%Zaim?W>g><C$Hr?4Zm)EP;0jVIGDTIlv@{_;C%?v=?@mE#yfS6GDhK}?7Hsw}_h
znE2Fk7EF3*G2nl0-%H|hb%*06lj)$&?lbDq87o30>}|MO{1;rx!V7*&l~23t+Ugdy
zB{Fd&%bF&%+kU}5sVyDS{}5I7RQUpM_7wOq!1#@c?hf{}$q0YZLGCpEj(hd?8^8SG
z;@HQ}fB46(fuZ+)Jou;5`LXHOM{fK at Y+g8kkV)HGxtftR_}Z@!ihn&vs9U#Sc^NnB
zP#mD%yB755O0E9HZ{cOZZzH6K2Q8*JwN#?|>U5sVqL5Tm9dTkTMhs66nYR)7l?6YJ
z;}&xVvzVh-XQ)2Dy0T4fC>T6>(UUTG3b9l)OuS_x#{5b+OpJ#OBQYh+Dz?IYypzTy
zo*d-KjWR9=aEoP$UgxMg9K9$pef$;IyzIIuI%f^;dD)#bxC-UEk#6Fxe&Tq)5&;`m
z!f7SkO^n!yk*C$*b~LVZnUo=`5}8)UrW4H%%J at MMKUu&#ydjvMp*ClzLdC90)Cxx}
zCFm8&csngR^P+RQV&_z0N)#>|TvO_|;HA$dT%Q|US=Ic>fD-OhB4Ih&PsF;Fs8xw(
z6x-_e$p?ts4dBf*-tdwo7Vkh7tesxVF^fLt7Dufmn6)CcS)%`@WBROTgsj+pU3L`$
zO<yO{t&GNq*z}pxkJF at v0P_a3B2o7^dOb(Ktz)!+Il3$v&;3jm3aTqBdH|4Ti|$R)
zbs45=>i5q<rphS9V<N`wL}WVg`i2GXEa0sGe#AHCZuywaQvID0y$%8RZLX~BnUx!o
zs*n<$1=T&5bLLgZ(OvM*4w(puY6t-ARBT@?<DG8utD>>Yl3P5v#ghLB;6V%C;4w at e
z6^-|ccr$>X@{M2aNYrA2zEi5-;plCSUgBtA at E&)lkA2TIFM8$-&MDbh=$r at kA=z<=
z)31z%729Wj#SeM1RK)ka<oyi1Mb#OGKO!KPu4#~phH&&IP?<>joJAF&^8ix??^1?d
znW2k5W<5vsHTCegr149FlPzB4<V#j!*spYDl%K at m?2Rd%JEgj(RN<!B4st30VrD=0
ze22t9sH-{pY@)93^m!gXWXXp`<HG>?SaXH9ipFi0EZu};-}lNR{lu6_v7J3Qr at BCg
zABaK$Ff=&Rvb$h#1DI2)`DE=fNEZ|}L%p3~c6Gqx@(m*>5c~iaEeG1HN;po8e?*Mg
zfwJ7JPskcv^Q!Pn at 0nNIry#ceHI}}sV*tHn05Dgpu`f;TR-7PmV?isHN4%VnD@<uQ
zg8ql?#Q5~zmwfGW5SXm#HY2t}^?`af)zqtaB|#TT_1iPla)P;4qSs3G8gvkzj{%vj
zK%vzQhw+m%-sCrC<Pp0v5(fXukXMO3t&aMM(F~zAhhIYv`T>kJSHmEGff()dra*uO
zXLIa-6jts82GwkJS8Ne)1n^#c{H~05%QX)IB#5*orMZe}kW?#LxzC9nK&4q&gNn(~
z;JF~_j*(jkYKtrZ!{wSsUJ|$}h4EH4!zvM|o(!CIelELGP_+h6bN{MD-HkJwP<#?|
zYcFZZ*MhepOAFrh;>Td&xR<Q4#?neeQ at vI|;fxYtmFiENDX{^{^p5Ck&Mqftt+C~5
zp_-S$CIB;PSx2uVs6Dn{pvqoy*MgsT$$Qy&r!vGV(atg;GbekdWcPK^sdW at kpX|=6
z6IZmZqwxUkVK1<m+HLO8T_3fcpb`3m1tG1u69qRgdA*WOMs`C(N~>Crmh8}zVQe(%
zE8l?sHy>gVs)GFvY&o1ns|G9UiR*7`UlN3V1mD<i!g#<iC1}2*y~EM2fkCOKr+0XG
zAb6p-E7B{4{`=}^WFXr6pN|GF4)!`)j`BzO^8-;<XlZo_K`GSQ;|w~FI~)#y4>^Qm
z((#^_)*#;&YHj0rz9rZb6WWfv+56_j$k-7n8jTDDFGYKgTne9$NTJ at N7cOYA{u{V=
B{ht5;
literal 0
HcmV?d00001
diff --git a/llvm/test/Bitcode/aarch64-target-memory-attribute.ll b/llvm/test/Bitcode/aarch64-target-memory-attribute.ll
new file mode 100644
index 0000000000000..1ead9e5e878ba
--- /dev/null
+++ b/llvm/test/Bitcode/aarch64-target-memory-attribute.ll
@@ -0,0 +1,36 @@
+; RUN: llvm-dis < %S/Inputs/aarch64-memory-attribute-upgrade.bc | FileCheck %s --check-prefix=AARCH64
+; RUN: llvm-dis < %S/Inputs/x86-memory-attribute-upgrade.bc | FileCheck %s --check-prefix=NON-AARCH64
+
+; The .bc inputs were generated by an older LLVM memory-attribute encoding,
+; before AArch64 target memory was split out from inaccessible memory.
+; The code was compiled using x86 and aarch64 hosts.
+
+target triple = "aarch64-linux"
+
+define void @test_inaccessible_read() #0 {
+; AARCH64: ; Function Attrs: memory(inaccessiblemem: read, target_mem: read)
+; AARCH64-NEXT: define void @test_inaccessible_read()
+; NON-AARCH64: ; Function Attrs: memory(inaccessiblemem: read)
+; NON-AARCH64-NEXT: define void @test_inaccessible_read()
+ ret void
+}
+
+define void @test_inaccessible_readwrite() #1 {
+; AARCH64: ; Function Attrs: memory(inaccessiblemem: readwrite, target_mem: readwrite)
+; AARCH64-NEXT: define void @test_inaccessible_readwrite()
+; NON-AARCH64: ; Function Attrs: memory(inaccessiblemem: readwrite)
+; NON-AARCH64-NEXT: define void @test_inaccessible_readwrite()
+ ret void
+}
+
+define void @test_inaccessible_none() #2 {
+; AARCH64: ; Function Attrs: memory(none)
+; AARCH64-NEXT: define void @test_inaccessible_none()
+; NON-AARCH64: ; Function Attrs: memory(none)
+; NON-AARCH64-NEXT: define void @test_inaccessible_none()
+ ret void
+}
+
+attributes #0 = { memory(inaccessiblemem: read) }
+attributes #1 = { memory(inaccessiblemem: readwrite) }
+attributes #2 = { memory(inaccessiblemem: none) }
diff --git a/llvm/test/Transforms/LICM/AArch64/sme-fp8-hoits.ll b/llvm/test/Transforms/LICM/AArch64/sme-fp8-hoits.ll
index 85f079fc135c3..1efb6688e0208 100644
--- a/llvm/test/Transforms/LICM/AArch64/sme-fp8-hoits.ll
+++ b/llvm/test/Transforms/LICM/AArch64/sme-fp8-hoits.ll
@@ -12,10 +12,10 @@ define void @fp8_fmopa_loop(ptr %lhs, ptr %rhs, i64 %fpmr, i64 %n) {
; CHECK-NEXT: [[PTRUE:%.*]] = call <vscale x 16 x i1> @llvm.aarch64.sve.ptrue.nxv16i1(i32 31)
; CHECK-NEXT: [[LHS_LOAD:%.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.ld1.nxv16i8.p0(<vscale x 16 x i1> [[PTRUE]], ptr [[LHS]])
; CHECK-NEXT: [[RHS_LOAD:%.*]] = call <vscale x 16 x i8> @llvm.aarch64.sve.ld1.nxv16i8.p0(<vscale x 16 x i1> [[PTRUE]], ptr [[RHS]])
+; CHECK-NEXT: call void @llvm.aarch64.set.fpmr(i64 [[FPMR]])
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
; CHECK-NEXT: [[IV:%.*]] = phi i64 [ 0, %[[ENTRY]] ], [ [[IV_NEXT:%.*]], %[[LOOP]] ]
-; CHECK-NEXT: call void @llvm.aarch64.set.fpmr(i64 [[FPMR]])
; CHECK-NEXT: call void @llvm.aarch64.sme.fp8.fmopa.za32(i32 0, <vscale x 16 x i1> [[PTRUE]], <vscale x 16 x i1> [[PTRUE]], <vscale x 16 x i8> [[LHS_LOAD]], <vscale x 16 x i8> [[RHS_LOAD]])
; CHECK-NEXT: [[IV_NEXT]] = add nuw i64 [[IV]], 1
; CHECK-NEXT: [[COND:%.*]] = icmp ult i64 [[IV_NEXT]], [[N]]
More information about the llvm-commits
mailing list