From c5f205bf764e7ae79fff49efcd984834799fdc6b Mon Sep 17 00:00:00 2001 From: trcrsired Date: Mon, 9 Oct 2023 01:45:56 -0400 Subject: [PATCH 001/111] initial commit for adding wasm stack tagging pass --- llvm/lib/Target/WebAssembly/CMakeLists.txt | 1 + llvm/lib/Target/WebAssembly/WebAssembly.h | 2 + .../WebAssembly/WebAssemblyStackTagging.cpp | 41 +++++++++++++++++++ .../WebAssembly/WebAssemblyTargetMachine.cpp | 7 +++- 4 files changed, 50 insertions(+), 1 deletion(-) create mode 100644 llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp diff --git a/llvm/lib/Target/WebAssembly/CMakeLists.txt b/llvm/lib/Target/WebAssembly/CMakeLists.txt index bb2ccea5c1459..7fda21847c7a1 100644 --- a/llvm/lib/Target/WebAssembly/CMakeLists.txt +++ b/llvm/lib/Target/WebAssembly/CMakeLists.txt @@ -42,6 +42,7 @@ add_llvm_target(WebAssemblyCodeGen WebAssemblyNullifyDebugValueLists.cpp WebAssemblyOptimizeLiveIntervals.cpp WebAssemblyOptimizeReturned.cpp + WebAssemblyStackTagging.cpp WebAssemblyPeephole.cpp WebAssemblyRegisterInfo.cpp WebAssemblyRegColoring.cpp diff --git a/llvm/lib/Target/WebAssembly/WebAssembly.h b/llvm/lib/Target/WebAssembly/WebAssembly.h index 91765ad117bdb..1c56bf1c0cdb2 100644 --- a/llvm/lib/Target/WebAssembly/WebAssembly.h +++ b/llvm/lib/Target/WebAssembly/WebAssembly.h @@ -53,6 +53,7 @@ FunctionPass *createWebAssemblyExplicitLocals(); FunctionPass *createWebAssemblyLowerBrUnless(); FunctionPass *createWebAssemblyRegNumbering(); FunctionPass *createWebAssemblyDebugFixup(); +FunctionPass *createWebAssemblyStackTaggingPass(); FunctionPass *createWebAssemblyPeephole(); ModulePass *createWebAssemblyMCLowerPrePass(); @@ -77,6 +78,7 @@ void initializeWebAssemblyMCLowerPrePassPass(PassRegistry &); void initializeWebAssemblyMemIntrinsicResultsPass(PassRegistry &); void initializeWebAssemblyNullifyDebugValueListsPass(PassRegistry &); void initializeWebAssemblyOptimizeLiveIntervalsPass(PassRegistry &); +void initializeWebAssemblyStackTaggingPass(PassRegistry &); void initializeWebAssemblyPeepholePass(PassRegistry &); void initializeWebAssemblyRegColoringPass(PassRegistry &); void initializeWebAssemblyRegNumberingPass(PassRegistry &); diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp new file mode 100644 index 0000000000000..87db0f8c9f923 --- /dev/null +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -0,0 +1,41 @@ +//===- WebAssemblyTargetMachine.cpp - Define TargetMachine for WebAssembly -==// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +#include "WebAssembly.h" +#include "llvm/Pass.h" +#include "llvm/IR/Function.h" +#include "llvm/Support/raw_ostream.h" + +using namespace llvm; + +namespace { + +struct WebAssemblyStackTaggingPass : public FunctionPass { + static char ID; + WebAssemblyStackTaggingPass() : FunctionPass(ID) {} + + bool runOnFunction(Function &F) override { +#if 0 + errs() << "Hello: "; + errs().write_escaped(F.getName()) << '\n'; +#endif + return false; + } +}; // end of struct Hello + +} + +char WebAssemblyStackTaggingPass::ID = 0; + +void llvm::initializeWebAssemblyStackTaggingPass(PassRegistry &) +{ + +} + +FunctionPass *llvm::createWebAssemblyStackTaggingPass() { + return new WebAssemblyStackTaggingPass(); +} diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp index 88c727796e0df..8ef5bed334569 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp @@ -80,6 +80,7 @@ extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeWebAssemblyTarget() { initializeWebAssemblyRegNumberingPass(PR); initializeWebAssemblyDebugFixupPass(PR); initializeWebAssemblyPeepholePass(PR); + initializeWebAssemblyStackTaggingPass(PR); initializeWebAssemblyMCLowerPrePassPass(PR); initializeWebAssemblyLowerRefTypesIntPtrConvPass(PR); initializeWebAssemblyFixBrTableDefaultsPass(PR); @@ -426,10 +427,14 @@ void WebAssemblyPassConfig::addIRPasses() { // to match. addPass(createWebAssemblyFixFunctionBitcasts()); + auto optlevel = this->getOptLevel(); + // Optimize "returned" function attributes. - if (getOptLevel() != CodeGenOptLevel::None) + if (optlevel != CodeGenOptLevel::None) addPass(createWebAssemblyOptimizeReturned()); + addPass(createWebAssemblyStackTaggingPass()); + basicCheckForEHAndSjLj(TM); // If exception handling is not enabled and setjmp/longjmp handling is From 1254981ea75d4d7256530f9451faa66d088c9a1a Mon Sep 17 00:00:00 2001 From: trcrsired Date: Mon, 9 Oct 2023 01:57:46 -0400 Subject: [PATCH 002/111] add sanitizememtag attribute detect for wasm stacking tagging --- .../WebAssembly/WebAssemblyStackTagging.cpp | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 87db0f8c9f923..9894c123163d9 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -18,21 +18,20 @@ struct WebAssemblyStackTaggingPass : public FunctionPass { static char ID; WebAssemblyStackTaggingPass() : FunctionPass(ID) {} - bool runOnFunction(Function &F) override { -#if 0 - errs() << "Hello: "; - errs().write_escaped(F.getName()) << '\n'; -#endif - return false; - } + bool runOnFunction(Function &) override; }; // end of struct Hello } +bool WebAssemblyStackTaggingPass::runOnFunction(Function & Fn) { + if (!Fn.hasFnAttribute(Attribute::SanitizeMemTag)) + return false; + return true; +} + char WebAssemblyStackTaggingPass::ID = 0; -void llvm::initializeWebAssemblyStackTaggingPass(PassRegistry &) -{ +void llvm::initializeWebAssemblyStackTaggingPass(PassRegistry &) { } From 8184339d263c507942a4684d98fc4b1e79f25808 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Mon, 9 Oct 2023 02:35:34 -0400 Subject: [PATCH 003/111] Initial attempt on stack tagging for wasm --- .../Target/WebAssembly/WebAssemblyStackTagging.cpp | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 9894c123163d9..69dc9dc49f8d8 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -9,6 +9,9 @@ #include "llvm/Pass.h" #include "llvm/IR/Function.h" #include "llvm/Support/raw_ostream.h" +#include "llvm/Analysis/AliasAnalysis.h" +#include "llvm/Analysis/StackSafetyAnalysis.h" +#include "llvm/Transforms/Utils/MemoryTaggingSupport.h" using namespace llvm; @@ -16,6 +19,8 @@ namespace { struct WebAssemblyStackTaggingPass : public FunctionPass { static char ID; + StackSafetyGlobalInfo const *SSI = nullptr; + AAResults *AA = nullptr; WebAssemblyStackTaggingPass() : FunctionPass(ID) {} bool runOnFunction(Function &) override; @@ -26,10 +31,19 @@ struct WebAssemblyStackTaggingPass : public FunctionPass { bool WebAssemblyStackTaggingPass::runOnFunction(Function & Fn) { if (!Fn.hasFnAttribute(Attribute::SanitizeMemTag)) return false; + SSI = &getAnalysis().getResult(); return true; } char WebAssemblyStackTaggingPass::ID = 0; +#if 0 +INITIALIZE_PASS_BEGIN(WebAssemblyStackTaggingPass, DEBUG_TYPE, "WebAssembly Stack Tagging", + false, false) +INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass) +INITIALIZE_PASS_DEPENDENCY(StackSafetyGlobalInfoWrapperPass) +INITIALIZE_PASS_END(WebAssemblyStackTaggingPass, DEBUG_TYPE, "WebAssembly Stack Tagging", + false, false) +#endif void llvm::initializeWebAssemblyStackTaggingPass(PassRegistry &) { From 3bce1003700bac415a609c134f53d5c828443f6f Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 19 Oct 2023 11:59:16 -0400 Subject: [PATCH 004/111] Enable memtag --- clang/lib/Driver/ToolChain.cpp | 3 ++- clang/lib/Driver/ToolChains/CommonArgs.cpp | 21 ++++++++++++++------- 2 files changed, 16 insertions(+), 8 deletions(-) diff --git a/clang/lib/Driver/ToolChain.cpp b/clang/lib/Driver/ToolChain.cpp index ab19166f18c2d..43d52b9254bf0 100644 --- a/clang/lib/Driver/ToolChain.cpp +++ b/clang/lib/Driver/ToolChain.cpp @@ -1325,7 +1325,8 @@ SanitizerMask ToolChain::getSupportedSanitizers() const { if (getTriple().getArch() == llvm::Triple::x86_64 || getTriple().isAArch64(64) || getTriple().isRISCV()) Res |= SanitizerKind::ShadowCallStack; - if (getTriple().isAArch64(64)) + if (getTriple().isAArch64(64) || + getTriple().isWasm()) Res |= SanitizerKind::MemTag; return Res; } diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp index 25fd940584624..93a37c7dea1bb 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.cpp +++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp @@ -1268,16 +1268,23 @@ bool tools::addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args, CmdArgs.push_back("--export-dynamic-symbol=__cfi_check"); if (SanArgs.hasMemTag()) { - if (!TC.getTriple().isAndroid()) { + if (TC.getTriple().isWasm()) + { + + } + else if (TC.getTriple().isAndroid()) { + CmdArgs.push_back( + Args.MakeArgString("--android-memtag-mode=" + SanArgs.getMemtagMode())); + if (SanArgs.hasMemtagHeap()) + CmdArgs.push_back("--android-memtag-heap"); + if (SanArgs.hasMemtagStack()) + CmdArgs.push_back("--android-memtag-stack"); + } + else + { TC.getDriver().Diag(diag::err_drv_unsupported_opt_for_target) << "-fsanitize=memtag*" << TC.getTriple().str(); } - CmdArgs.push_back( - Args.MakeArgString("--android-memtag-mode=" + SanArgs.getMemtagMode())); - if (SanArgs.hasMemtagHeap()) - CmdArgs.push_back("--android-memtag-heap"); - if (SanArgs.hasMemtagStack()) - CmdArgs.push_back("--android-memtag-stack"); } return !StaticRuntimes.empty() || !NonWholeStaticRuntimes.empty(); From 3408a933415777b26d98e2d06bf4b38eda318623 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 19 Oct 2023 13:12:40 -0400 Subject: [PATCH 005/111] sanitizer args enable memtag for wasm --- clang/lib/Driver/SanitizerArgs.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/clang/lib/Driver/SanitizerArgs.cpp b/clang/lib/Driver/SanitizerArgs.cpp index ad68c086b7179..8607d5d4f74c8 100644 --- a/clang/lib/Driver/SanitizerArgs.cpp +++ b/clang/lib/Driver/SanitizerArgs.cpp @@ -1383,6 +1383,7 @@ void SanitizerArgs::addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args, } if (Sanitizers.has(SanitizerKind::MemtagStack) && + !TC.getTriple().isWasm() && !hasTargetFeatureMTE(CmdArgs)) TC.getDriver().Diag(diag::err_stack_tagging_requires_hardware_feature); } From ecbb203135f393147c955933475c59981c28dba6 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 19 Oct 2023 19:20:53 -0400 Subject: [PATCH 006/111] Fix crashing with wasm pass --- .../WebAssembly/WebAssemblyStackTagging.cpp | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 69dc9dc49f8d8..1b7bca19a226c 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -24,6 +24,18 @@ struct WebAssemblyStackTaggingPass : public FunctionPass { WebAssemblyStackTaggingPass() : FunctionPass(ID) {} bool runOnFunction(Function &) override; +private: +#if 0 + bool const UseStackSafety = false; + void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.setPreservesCFG(); + AU.addRequired(); +#if 0 + if (MergeInit) + AU.addRequired(); +#endif + } +#endif }; // end of struct Hello } @@ -31,8 +43,11 @@ struct WebAssemblyStackTaggingPass : public FunctionPass { bool WebAssemblyStackTaggingPass::runOnFunction(Function & Fn) { if (!Fn.hasFnAttribute(Attribute::SanitizeMemTag)) return false; +#if 0 SSI = &getAnalysis().getResult(); return true; +#endif + return false; } char WebAssemblyStackTaggingPass::ID = 0; From cec0406c83a9df7f756b2cd97af770d727d41aca Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 20 Oct 2023 14:51:40 -0400 Subject: [PATCH 007/111] WebAssemblyStackTagging Fix compilation --- .../WebAssembly/WebAssemblyStackTagging.cpp | 28 +++++++++---------- 1 file changed, 13 insertions(+), 15 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 1b7bca19a226c..603509d42d1f4 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -6,6 +6,7 @@ // //===----------------------------------------------------------------------===// #include "WebAssembly.h" +#include "llvm/InitializePasses.h" #include "llvm/Pass.h" #include "llvm/IR/Function.h" #include "llvm/Support/raw_ostream.h" @@ -15,18 +16,19 @@ using namespace llvm; +#define DEBUG_TYPE "wasm-stack-tagging" + namespace { -struct WebAssemblyStackTaggingPass : public FunctionPass { +struct WebAssemblyStackTagging : public FunctionPass { static char ID; StackSafetyGlobalInfo const *SSI = nullptr; AAResults *AA = nullptr; - WebAssemblyStackTaggingPass() : FunctionPass(ID) {} + WebAssemblyStackTagging() : FunctionPass(ID) {} bool runOnFunction(Function &) override; private: #if 0 - bool const UseStackSafety = false; void getAnalysisUsage(AnalysisUsage &AU) const override { AU.setPreservesCFG(); AU.addRequired(); @@ -40,30 +42,26 @@ struct WebAssemblyStackTaggingPass : public FunctionPass { } -bool WebAssemblyStackTaggingPass::runOnFunction(Function & Fn) { +bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { if (!Fn.hasFnAttribute(Attribute::SanitizeMemTag)) return false; #if 0 SSI = &getAnalysis().getResult(); return true; #endif - return false; + return false; } -char WebAssemblyStackTaggingPass::ID = 0; -#if 0 -INITIALIZE_PASS_BEGIN(WebAssemblyStackTaggingPass, DEBUG_TYPE, "WebAssembly Stack Tagging", +char WebAssemblyStackTagging::ID = 0; +INITIALIZE_PASS_BEGIN(WebAssemblyStackTagging, DEBUG_TYPE, "WebAssembly Stack Tagging", false, false) +#if 0 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass) +#endif INITIALIZE_PASS_DEPENDENCY(StackSafetyGlobalInfoWrapperPass) -INITIALIZE_PASS_END(WebAssemblyStackTaggingPass, DEBUG_TYPE, "WebAssembly Stack Tagging", +INITIALIZE_PASS_END(WebAssemblyStackTagging, DEBUG_TYPE, "WebAssembly Stack Tagging", false, false) -#endif - -void llvm::initializeWebAssemblyStackTaggingPass(PassRegistry &) { - -} FunctionPass *llvm::createWebAssemblyStackTaggingPass() { - return new WebAssemblyStackTaggingPass(); + return new WebAssemblyStackTagging(); } From ee8fc5b7c0ac15a34963cb4a55c8a0dfeeff1325 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 20 Oct 2023 15:26:02 -0400 Subject: [PATCH 008/111] Enable SSI analysis --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 603509d42d1f4..0d25c42c2283e 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -28,7 +28,7 @@ struct WebAssemblyStackTagging : public FunctionPass { bool runOnFunction(Function &) override; private: -#if 0 +#if 1 void getAnalysisUsage(AnalysisUsage &AU) const override { AU.setPreservesCFG(); AU.addRequired(); @@ -45,11 +45,8 @@ struct WebAssemblyStackTagging : public FunctionPass { bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { if (!Fn.hasFnAttribute(Attribute::SanitizeMemTag)) return false; -#if 0 SSI = &getAnalysis().getResult(); return true; -#endif - return false; } char WebAssemblyStackTagging::ID = 0; From c55425a5f25b1126d57ac67fb5871bbd92fb688e Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 20 Oct 2023 15:58:14 -0400 Subject: [PATCH 009/111] Add some code to webassembly stack tagging --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 0d25c42c2283e..10a00dc072341 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -46,6 +46,11 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { if (!Fn.hasFnAttribute(Attribute::SanitizeMemTag)) return false; SSI = &getAnalysis().getResult(); +#if 0 + for (auto &I : SInfo.AllocasToInstrument) { + LLVM_DEBUG(dbgs() << I << "\n"); + } +#endif return true; } From b2f9cb2364a5a4c2c9a3e936cec2aa1eff6f4b0a Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 20 Oct 2023 17:23:21 -0400 Subject: [PATCH 010/111] WebAssemblyStackTagging instruction compile --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 10a00dc072341..2b2c241424d55 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -9,6 +9,7 @@ #include "llvm/InitializePasses.h" #include "llvm/Pass.h" #include "llvm/IR/Function.h" +#include "llvm/IR/InstIterator.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Analysis/AliasAnalysis.h" #include "llvm/Analysis/StackSafetyAnalysis.h" @@ -45,8 +46,13 @@ struct WebAssemblyStackTagging : public FunctionPass { bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { if (!Fn.hasFnAttribute(Attribute::SanitizeMemTag)) return false; + auto F = &Fn; SSI = &getAnalysis().getResult(); -#if 0 + memtag::StackInfoBuilder SIB(SSI); + for (Instruction &I : instructions(F)) + SIB.visit(I); + memtag::StackInfo &SInfo = SIB.get(); +#if 1 for (auto &I : SInfo.AllocasToInstrument) { LLVM_DEBUG(dbgs() << I << "\n"); } From e6b12455518e0fea331b67001058ac3972253423 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 20 Oct 2023 18:24:02 -0400 Subject: [PATCH 011/111] Wasm add DT, LI to wasm stack tagging --- .../WebAssembly/WebAssemblyStackTagging.cpp | 80 ++++++++++++++++++- 1 file changed, 79 insertions(+), 1 deletion(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 2b2c241424d55..e7686b61e1f19 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -10,6 +10,9 @@ #include "llvm/Pass.h" #include "llvm/IR/Function.h" #include "llvm/IR/InstIterator.h" +#include "llvm/IR/ValueHandle.h" +#include "llvm/IR/IRBuilder.h" +#include "llvm/Transforms/Utils/Local.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Analysis/AliasAnalysis.h" #include "llvm/Analysis/StackSafetyAnalysis.h" @@ -21,6 +24,28 @@ using namespace llvm; namespace { +static cl::opt ClMergeInit( + "stack-tagging-merge-init", cl::Hidden, cl::init(true), + cl::desc("merge stack variable initializers with tagging when possible")); + +static cl::opt + ClUseStackSafety("stack-tagging-use-stack-safety", cl::Hidden, + cl::init(true), + cl::desc("Use Stack Safety analysis results")); + +static cl::opt ClScanLimit("stack-tagging-merge-init-scan-limit", + cl::init(40), cl::Hidden); + +static cl::opt + ClMergeInitSizeLimit("stack-tagging-merge-init-size-limit", cl::init(272), + cl::Hidden); + +static cl::opt ClMaxLifetimes( + "stack-tagging-max-lifetimes-for-alloca", cl::Hidden, cl::init(3), + cl::ReallyHidden, + cl::desc("How many lifetime ends to handle for a single alloca."), + cl::Optional); + struct WebAssemblyStackTagging : public FunctionPass { static char ID; StackSafetyGlobalInfo const *SSI = nullptr; @@ -41,6 +66,8 @@ struct WebAssemblyStackTagging : public FunctionPass { #endif }; // end of struct Hello +static const inline Align kTagGranuleSize = Align(16); + } bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { @@ -52,9 +79,60 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { for (Instruction &I : instructions(F)) SIB.visit(I); memtag::StackInfo &SInfo = SIB.get(); + + std::unique_ptr DeleteDT; + DominatorTree *DT = nullptr; + if (auto *P = getAnalysisIfAvailable()) + DT = &P->getDomTree(); + + if (DT == nullptr) { + DeleteDT = std::make_unique(*F); + DT = DeleteDT.get(); + } + +#if 0 + std::unique_ptr DeletePDT; + PostDominatorTree *PDT = nullptr; + if (auto *P = getAnalysisIfAvailable()) + PDT = &P->getPostDomTree(); + + if (PDT == nullptr) { + DeletePDT = std::make_unique(*F); + PDT = DeletePDT.get(); + } +#endif + + std::unique_ptr DeleteLI; + LoopInfo *LI = nullptr; + if (auto *LIWP = getAnalysisIfAvailable()) { + LI = &LIWP->getLoopInfo(); + } else { + DeleteLI = std::make_unique(*DT); + LI = DeleteLI.get(); + } + + #if 1 + int NextTag = 0; for (auto &I : SInfo.AllocasToInstrument) { - LLVM_DEBUG(dbgs() << I << "\n"); + memtag::AllocaInfo &Info = I.second; + TrackingVH OldAI = Info.AI; + memtag::alignAndPadAlloca(Info, kTagGranuleSize); + AllocaInst *AI = Info.AI; + int Tag = NextTag; + NextTag = (NextTag + 1) % 16; + IRBuilder<> IRB(Info.AI->getNextNode()); + + // Calls to functions that may return twice (e.g. setjmp) confuse the + // postdominator analysis, and will leave us to keep memory tagged after + // function return. Work around this by always untagging at every return + // statement if return_twice functions are called. + bool StandardLifetime = + SInfo.UnrecognizedLifetimes.empty() && + memtag::isStandardLifetime(Info.LifetimeStart, Info.LifetimeEnd, DT, LI, + ClMaxLifetimes) && + !SInfo.CallsReturnTwice; +// LLVM_DEBUG(dbgs() << I << "\n"); } #endif return true; From 06271b8eabf79cfc1ca22028e770bb7520691218 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 20 Oct 2023 18:58:45 -0400 Subject: [PATCH 012/111] Webassembly stack tagging remove cl::opt --- .../WebAssembly/WebAssemblyStackTagging.cpp | 95 ++++++++++++++----- 1 file changed, 70 insertions(+), 25 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index e7686b61e1f19..3fec2b858a337 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -16,6 +16,7 @@ #include "llvm/Support/raw_ostream.h" #include "llvm/Analysis/AliasAnalysis.h" #include "llvm/Analysis/StackSafetyAnalysis.h" +#include "llvm/Analysis/PostDominators.h" #include "llvm/Transforms/Utils/MemoryTaggingSupport.h" using namespace llvm; @@ -24,34 +25,16 @@ using namespace llvm; namespace { -static cl::opt ClMergeInit( - "stack-tagging-merge-init", cl::Hidden, cl::init(true), - cl::desc("merge stack variable initializers with tagging when possible")); - -static cl::opt - ClUseStackSafety("stack-tagging-use-stack-safety", cl::Hidden, - cl::init(true), - cl::desc("Use Stack Safety analysis results")); - -static cl::opt ClScanLimit("stack-tagging-merge-init-scan-limit", - cl::init(40), cl::Hidden); - -static cl::opt - ClMergeInitSizeLimit("stack-tagging-merge-init-size-limit", cl::init(272), - cl::Hidden); - -static cl::opt ClMaxLifetimes( - "stack-tagging-max-lifetimes-for-alloca", cl::Hidden, cl::init(3), - cl::ReallyHidden, - cl::desc("How many lifetime ends to handle for a single alloca."), - cl::Optional); - struct WebAssemblyStackTagging : public FunctionPass { static char ID; StackSafetyGlobalInfo const *SSI = nullptr; AAResults *AA = nullptr; WebAssemblyStackTagging() : FunctionPass(ID) {} + void tagAlloca(AllocaInst *AI, Instruction *InsertBefore, Value *Ptr, + uint64_t Size); + void untagAlloca(AllocaInst *AI, Instruction *InsertBefore, uint64_t Size); + bool runOnFunction(Function &) override; private: #if 1 @@ -70,6 +53,40 @@ static const inline Align kTagGranuleSize = Align(16); } +void WebAssemblyStackTagging::tagAlloca(AllocaInst *AI, Instruction *InsertBefore, + Value *Ptr, uint64_t Size) { + +#if 0 + auto SetTagZeroFunc = + Intrinsic::getDeclaration(F->getParent(), Intrinsic::aarch64_settag_zero); + auto StgpFunc = + Intrinsic::getDeclaration(F->getParent(), Intrinsic::aarch64_stgp); + + InitializerBuilder IB(Size, DL, Ptr, SetTagFunc, SetTagZeroFunc, StgpFunc); + bool LittleEndian = + Triple(AI->getModule()->getTargetTriple()).isLittleEndian(); + // Current implementation of initializer merging assumes little endianness. + if (MergeInit && !F->hasOptNone() && LittleEndian && + Size < ClMergeInitSizeLimit) { + LLVM_DEBUG(dbgs() << "collecting initializers for " << *AI + << ", size = " << Size << "\n"); + InsertBefore = collectInitializers(InsertBefore, Ptr, Size, IB); + } + + IRBuilder<> IRB(InsertBefore); + IB.generate(IRB); +#endif +} + +void WebAssemblyStackTagging::untagAlloca(AllocaInst *AI, Instruction *InsertBefore, + uint64_t Size) { +#if 0 + IRBuilder<> IRB(InsertBefore); + IRB.CreateCall(SetTagFunc, {IRB.CreatePointerCast(AI, IRB.getPtrTy()), + ConstantInt::get(IRB.getInt64Ty(), Size)}); +#endif +} + bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { if (!Fn.hasFnAttribute(Attribute::SanitizeMemTag)) return false; @@ -90,7 +107,6 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { DT = DeleteDT.get(); } -#if 0 std::unique_ptr DeletePDT; PostDominatorTree *PDT = nullptr; if (auto *P = getAnalysisIfAvailable()) @@ -100,7 +116,6 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { DeletePDT = std::make_unique(*F); PDT = DeletePDT.get(); } -#endif std::unique_ptr DeleteLI; LoopInfo *LI = nullptr; @@ -130,8 +145,38 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { bool StandardLifetime = SInfo.UnrecognizedLifetimes.empty() && memtag::isStandardLifetime(Info.LifetimeStart, Info.LifetimeEnd, DT, LI, - ClMaxLifetimes) && + 3) && !SInfo.CallsReturnTwice; +#if 0 + if (StandardLifetime) { + IntrinsicInst *Start = Info.LifetimeStart[0]; + uint64_t Size = + cast(Start->getArgOperand(0))->getZExtValue(); + Size = alignTo(Size, kTagGranuleSize); + tagAlloca(AI, Start->getNextNode(), Start->getArgOperand(1), Size); + + auto TagEnd = [&](Instruction *Node) { untagAlloca(AI, Node, Size); }; + if (!DT || !PDT || + !memtag::forAllReachableExits(*DT, *PDT, *LI, Start, Info.LifetimeEnd, + SInfo.RetVec, TagEnd)) { + for (auto *End : Info.LifetimeEnd) + End->eraseFromParent(); + } + } else { + uint64_t Size = *Info.AI->getAllocationSize(*DL); + Value *Ptr = IRB.CreatePointerCast(TagPCall, IRB.getPtrTy()); + tagAlloca(AI, &*IRB.GetInsertPoint(), Ptr, Size); + for (auto *RI : SInfo.RetVec) { + untagAlloca(AI, RI, Size); + } + // We may have inserted tag/untag outside of any lifetime interval. + // Remove all lifetime intrinsics for this alloca. + for (auto *II : Info.LifetimeStart) + II->eraseFromParent(); + for (auto *II : Info.LifetimeEnd) + II->eraseFromParent(); + } +#endif // LLVM_DEBUG(dbgs() << I << "\n"); } #endif From 7b91fd76cd3e9091e5abcb1dd9e2fb238ca83a5d Mon Sep 17 00:00:00 2001 From: trcrsired Date: Tue, 24 Oct 2023 19:35:24 -0400 Subject: [PATCH 013/111] add webassembly global tagging --- llvm/lib/Target/WebAssembly/CMakeLists.txt | 1 + llvm/lib/Target/WebAssembly/WebAssembly.h | 2 + .../WebAssembly/WebAssemblyGlobalsTagging.cpp | 144 ++++++++++++++++++ .../WebAssembly/WebAssemblyStackTagging.cpp | 1 + 4 files changed, 148 insertions(+) create mode 100644 llvm/lib/Target/WebAssembly/WebAssemblyGlobalsTagging.cpp diff --git a/llvm/lib/Target/WebAssembly/CMakeLists.txt b/llvm/lib/Target/WebAssembly/CMakeLists.txt index 7fda21847c7a1..06e89da6fd850 100644 --- a/llvm/lib/Target/WebAssembly/CMakeLists.txt +++ b/llvm/lib/Target/WebAssembly/CMakeLists.txt @@ -59,6 +59,7 @@ add_llvm_target(WebAssemblyCodeGen WebAssemblyTargetObjectFile.cpp WebAssemblyTargetTransformInfo.cpp WebAssemblyUtilities.cpp + WebAssemblyGlobalsTagging.cpp DEPENDS intrinsics_gen diff --git a/llvm/lib/Target/WebAssembly/WebAssembly.h b/llvm/lib/Target/WebAssembly/WebAssembly.h index 1c56bf1c0cdb2..14b243ce01ac9 100644 --- a/llvm/lib/Target/WebAssembly/WebAssembly.h +++ b/llvm/lib/Target/WebAssembly/WebAssembly.h @@ -56,6 +56,7 @@ FunctionPass *createWebAssemblyDebugFixup(); FunctionPass *createWebAssemblyStackTaggingPass(); FunctionPass *createWebAssemblyPeephole(); ModulePass *createWebAssemblyMCLowerPrePass(); +ModulePass *createWebAssemblyGlobalsTaggingPass(); // PassRegistry initialization declarations. void initializeFixFunctionBitcastsPass(PassRegistry &); @@ -85,6 +86,7 @@ void initializeWebAssemblyRegNumberingPass(PassRegistry &); void initializeWebAssemblyRegStackifyPass(PassRegistry &); void initializeWebAssemblyReplacePhysRegsPass(PassRegistry &); void initializeWebAssemblySetP2AlignOperandsPass(PassRegistry &); +void initializeWebAssemblyGlobalsTaggingPass(PassRegistry &); namespace WebAssembly { enum TargetIndex { diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyGlobalsTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyGlobalsTagging.cpp new file mode 100644 index 0000000000000..b18f28a9ede91 --- /dev/null +++ b/llvm/lib/Target/WebAssembly/WebAssemblyGlobalsTagging.cpp @@ -0,0 +1,144 @@ +//===- WebAssemblyGlobalsTagging.cpp - Global tagging in IR -------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// + +#include "WebAssembly.h" +#if 0 +#include "llvm/BinaryFormat/ELF.h" +#endif +#include "llvm/IR/Attributes.h" +#include "llvm/IR/Constants.h" +#include "llvm/IR/GlobalValue.h" +#include "llvm/IR/GlobalVariable.h" +#include "llvm/IR/IRBuilder.h" +#include "llvm/IR/Module.h" +#include "llvm/Pass.h" +#include "llvm/Support/raw_ostream.h" + +#include +#include + +using namespace llvm; + +static const Align kTagGranuleSize = Align(16); + +static bool shouldTagGlobal(GlobalVariable &G) { + if (!G.isTagged()) + return false; + + assert(G.hasSanitizerMetadata() && + "Missing sanitizer metadata, but symbol is apparently tagged."); + GlobalValue::SanitizerMetadata Meta = G.getSanitizerMetadata(); + + // For now, don't instrument constant data, as it'll be in .rodata anyway. It + // may be worth instrumenting these in future to stop them from being used as + // gadgets. + if (G.getName().startswith("llvm.") || G.isThreadLocal() || G.isConstant()) { + Meta.Memtag = false; + G.setSanitizerMetadata(Meta); + return false; + } + + return true; +} + +// Technically, due to ELF symbol interposition semantics, we can't change the +// alignment or size of symbols. If we increase the alignment or size of a +// symbol, the compiler may make optimisations based on this new alignment or +// size. If the symbol is interposed, this optimisation could lead to +// alignment-related or OOB read/write crashes. +// +// This is handled in the linker. When the linker sees multiple declarations of +// a global variable, and some are tagged, and some are untagged, it resolves it +// to be an untagged definition - but preserves the tag-granule-rounded size and +// tag-granule-alignment. This should prevent these kind of crashes intra-DSO. +// For cross-DSO, it's been a reasonable contract that if you're interposing a +// sanitizer-instrumented global, then the interposer also needs to be +// sanitizer-instrumented. +// +// FIXME: In theory, this can be fixed by splitting the size/alignment of +// globals into two uses: an "output alignment" that's emitted to the ELF file, +// and an "optimisation alignment" that's used for optimisation. Thus, we could +// adjust the output alignment only, and still optimise based on the pessimistic +// pre-tagging size/alignment. +static void tagGlobalDefinition(Module &M, GlobalVariable *G) { + Constant *Initializer = G->getInitializer(); + uint64_t SizeInBytes = + M.getDataLayout().getTypeAllocSize(Initializer->getType()); + + uint64_t NewSize = alignTo(SizeInBytes, kTagGranuleSize); + if (SizeInBytes != NewSize) { + // Pad the initializer out to the next multiple of 16 bytes. + llvm::SmallVector Init(NewSize - SizeInBytes, 0); + Constant *Padding = ConstantDataArray::get(M.getContext(), Init); + Initializer = ConstantStruct::getAnon({Initializer, Padding}); + auto *NewGV = new GlobalVariable( + M, Initializer->getType(), G->isConstant(), G->getLinkage(), + Initializer, "", G, G->getThreadLocalMode(), G->getAddressSpace()); + NewGV->copyAttributesFrom(G); + NewGV->setComdat(G->getComdat()); + NewGV->copyMetadata(G, 0); + + NewGV->takeName(G); + G->replaceAllUsesWith(NewGV); + G->eraseFromParent(); + G = NewGV; + } + + G->setAlignment(std::max(G->getAlign().valueOrOne(), kTagGranuleSize)); + + // Ensure that tagged globals don't get merged by ICF - as they should have + // different tags at runtime. + G->setUnnamedAddr(GlobalValue::UnnamedAddr::None); +} + +namespace { +class WebAssemblyGlobalsTagging : public ModulePass { +public: + static char ID; + + explicit WebAssemblyGlobalsTagging() : ModulePass(ID) { + initializeWebAssemblyGlobalsTaggingPass(*PassRegistry::getPassRegistry()); + } + + bool runOnModule(Module &M) override; + + StringRef getPassName() const override { return "WebAssembly Globals Tagging"; } + +private: + std::set GlobalsToTag; +}; +} // anonymous namespace + +char WebAssemblyGlobalsTagging::ID = 0; + +bool WebAssemblyGlobalsTagging::runOnModule(Module &M) { + // No mutating the globals in-place, or iterator invalidation occurs. + std::vector GlobalsToTag; + for (GlobalVariable &G : M.globals()) { + if (G.isDeclaration() || !shouldTagGlobal(G)) + continue; + GlobalsToTag.push_back(&G); + } + + for (GlobalVariable *G : GlobalsToTag) { + tagGlobalDefinition(M, G); + } + + return true; +} + +INITIALIZE_PASS_BEGIN(WebAssemblyGlobalsTagging, "WebAssembly-globals-tagging", + "WebAssembly Globals Tagging Pass", false, false) +INITIALIZE_PASS_END(WebAssemblyGlobalsTagging, "WebAssembly-globals-tagging", + "WebAssembly Globals Tagging Pass", false, false) + +ModulePass *llvm::createWebAssemblyGlobalsTaggingPass() { + return new WebAssemblyGlobalsTagging(); +} diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 3fec2b858a337..fb54b1f993761 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -90,6 +90,7 @@ void WebAssemblyStackTagging::untagAlloca(AllocaInst *AI, Instruction *InsertBef bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { if (!Fn.hasFnAttribute(Attribute::SanitizeMemTag)) return false; + auto F = &Fn; SSI = &getAnalysis().getResult(); memtag::StackInfoBuilder SIB(SSI); From 1232193b49833fae5f53f176a45e094d57466ab5 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Tue, 24 Oct 2023 20:00:03 -0400 Subject: [PATCH 014/111] Add webassembly global tagging pass to wasm target machine --- llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp index f3748b44d33b0..7f25c44d2251e 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp @@ -91,6 +91,7 @@ extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeWebAssemblyTarget() { initializeWebAssemblyLowerRefTypesIntPtrConvPass(PR); initializeWebAssemblyFixBrTableDefaultsPass(PR); initializeWebAssemblyDAGToDAGISelPass(PR); + initializeWebAssemblyGlobalsTaggingPass(PR); } //===----------------------------------------------------------------------===// @@ -439,6 +440,7 @@ void WebAssemblyPassConfig::addIRPasses() { if (optlevel != CodeGenOptLevel::None) addPass(createWebAssemblyOptimizeReturned()); + addPass(createWebAssemblyGlobalsTaggingPass()); addPass(createWebAssemblyStackTaggingPass()); basicCheckForEHAndSjLj(TM); From d49e12edb95fb1e1084909822b5e0ae1b5d56f1c Mon Sep 17 00:00:00 2001 From: trcrsired Date: Tue, 24 Oct 2023 20:20:17 -0400 Subject: [PATCH 015/111] enable global tagging flags in asm printer --- llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp index 072c55f79caa9..6b707f5c44567 100644 --- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -730,10 +730,21 @@ void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) { if (GV->isTagged()) { Triple T = TM.getTargetTriple(); - if (T.getArch() != Triple::aarch64 || !T.isAndroid()) + auto arch = T.getArch(); + + bool supportMemtagGlobals = false; + + if (arch == Triple::wasm64) { + supportMemtagGlobals = true; + } + else if (arch == Triple::aarch64 && T.isAndroid()) { + supportMemtagGlobals = true; + } + + if (supportMemtagGlobals) OutContext.reportError(SMLoc(), "tagged symbols (-fsanitize=memtag-globals) are " - "only supported on AArch64 Android"); + "only supported on AArch64 Android or Wasm64"); OutStreamer->emitSymbolAttribute(EmittedSym, MAI->getMemtagAttr()); } From 263233bc251dbc5e5b94cf1539fb3940072c5686 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Tue, 24 Oct 2023 20:31:07 -0400 Subject: [PATCH 016/111] Only allow wasm64 for wasm to enable memtag --- clang/lib/Driver/ToolChains/CommonArgs.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp index b3c5782e6c31a..97322dcbb89b4 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.cpp +++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp @@ -1268,7 +1268,7 @@ bool tools::addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args, CmdArgs.push_back("--export-dynamic-symbol=__cfi_check"); if (SanArgs.hasMemTag()) { - if (TC.getTriple().isWasm()) + if (TC.getTriple().getArch() == ::llvm::Triple::wasm64) { } From b6592beea191899d02360be9fbafd36530ad03cc Mon Sep 17 00:00:00 2001 From: trcrsired Date: Tue, 24 Oct 2023 20:35:37 -0400 Subject: [PATCH 017/111] only allow wasm64 not wasm32 in clang driver's supported sanitizer list --- clang/lib/Driver/ToolChain.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clang/lib/Driver/ToolChain.cpp b/clang/lib/Driver/ToolChain.cpp index 43d52b9254bf0..adf1f11c8a25c 100644 --- a/clang/lib/Driver/ToolChain.cpp +++ b/clang/lib/Driver/ToolChain.cpp @@ -1326,7 +1326,7 @@ SanitizerMask ToolChain::getSupportedSanitizers() const { getTriple().isAArch64(64) || getTriple().isRISCV()) Res |= SanitizerKind::ShadowCallStack; if (getTriple().isAArch64(64) || - getTriple().isWasm()) + getTriple().getArch() == ::llvm::Triple::wasm64) Res |= SanitizerKind::MemTag; return Res; } From 14e2bc762c8d9fe0c7b659b9369037439503742c Mon Sep 17 00:00:00 2001 From: trcrsired Date: Tue, 24 Oct 2023 20:45:29 -0400 Subject: [PATCH 018/111] Fix the supportMemtagGlobals which should be inverse --- llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp index 6b707f5c44567..0998617bb8500 100644 --- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -741,7 +741,7 @@ void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) { supportMemtagGlobals = true; } - if (supportMemtagGlobals) + if (!supportMemtagGlobals) OutContext.reportError(SMLoc(), "tagged symbols (-fsanitize=memtag-globals) are " "only supported on AArch64 Android or Wasm64"); From fb6db21911cbd59fe8baf79902581dcac5d1f033 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Tue, 24 Oct 2023 20:52:53 -0400 Subject: [PATCH 019/111] correctly aligned for wasm globals --- llvm/lib/Target/WebAssembly/WebAssemblyGlobalsTagging.cpp | 5 ----- 1 file changed, 5 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyGlobalsTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyGlobalsTagging.cpp index b18f28a9ede91..d6b0061bc6061 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyGlobalsTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyGlobalsTagging.cpp @@ -9,9 +9,6 @@ //===----------------------------------------------------------------------===// #include "WebAssembly.h" -#if 0 -#include "llvm/BinaryFormat/ELF.h" -#endif #include "llvm/IR/Attributes.h" #include "llvm/IR/Constants.h" #include "llvm/IR/GlobalValue.h" @@ -126,11 +123,9 @@ bool WebAssemblyGlobalsTagging::runOnModule(Module &M) { continue; GlobalsToTag.push_back(&G); } - for (GlobalVariable *G : GlobalsToTag) { tagGlobalDefinition(M, G); } - return true; } From aaabbbc2af9eacc3f250972db6e9fe27af32156c Mon Sep 17 00:00:00 2001 From: trcrsired Date: Tue, 24 Oct 2023 21:20:08 -0400 Subject: [PATCH 020/111] Enable memtag for wasm MC --- llvm/lib/MC/MCWasmStreamer.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/llvm/lib/MC/MCWasmStreamer.cpp b/llvm/lib/MC/MCWasmStreamer.cpp index fbab72fb5f3d3..5f19dda4b8470 100644 --- a/llvm/lib/MC/MCWasmStreamer.cpp +++ b/llvm/lib/MC/MCWasmStreamer.cpp @@ -154,6 +154,12 @@ bool MCWasmStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) { Symbol->setNoStrip(); break; + case MCSA_Memtag: +#if 0 + Symbol->setMemtag(true); +#endif + break; + default: // unrecognized directive llvm_unreachable("unexpected MCSymbolAttr"); From f3f3a7a9e030caeb1ca1f06afdac00a0c923bd4c Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 26 Oct 2023 21:55:27 -0400 Subject: [PATCH 021/111] add memtag feature to webassembly --- llvm/lib/Target/WebAssembly/WebAssembly.td | 4 ++++ llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td | 4 ++++ llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h | 2 ++ 3 files changed, 10 insertions(+) diff --git a/llvm/lib/Target/WebAssembly/WebAssembly.td b/llvm/lib/Target/WebAssembly/WebAssembly.td index d538197450b65..a3dffa3d318d5 100644 --- a/llvm/lib/Target/WebAssembly/WebAssembly.td +++ b/llvm/lib/Target/WebAssembly/WebAssembly.td @@ -75,6 +75,10 @@ def FeatureMultiMemory : SubtargetFeature<"multimemory", "HasMultiMemory", "true", "Enable multiple memories">; +def FeatureMemtag : + SubtargetFeature<"memtag", "HasMemtag", "true", + "Enable memory tagging">; + //===----------------------------------------------------------------------===// // Architectures. //===----------------------------------------------------------------------===// diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td index 59ea9247bd86f..cc5109c8c12d0 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td @@ -74,6 +74,10 @@ def HasMultiMemory : Predicate<"Subtarget->hasMultiMemory()">, AssemblerPredicate<(all_of FeatureMultiMemory), "multimemory">; +def HasMemtag : + Predicate<"Subtarget->hasMemtag()">, + AssemblerPredicate<(all_of FeatureMemtag), "memtag">; + //===----------------------------------------------------------------------===// // WebAssembly-specific DAG Node Types. //===----------------------------------------------------------------------===// diff --git a/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h b/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h index 85d02b087c786..1b673c0ae1f0a 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h +++ b/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h @@ -50,6 +50,7 @@ class WebAssemblySubtarget final : public WebAssemblyGenSubtargetInfo { bool HasReferenceTypes = false; bool HasExtendedConst = false; bool HasMultiMemory = false; + bool HasMemtag = false; /// What processor and OS we're targeting. Triple TargetTriple; @@ -103,6 +104,7 @@ class WebAssemblySubtarget final : public WebAssemblyGenSubtargetInfo { bool hasTailCall() const { return HasTailCall; } bool hasReferenceTypes() const { return HasReferenceTypes; } bool hasMultiMemory() const { return HasMultiMemory; } + bool hasMemtag() const { return HasMemtag; } /// Parses features string setting specified subtarget options. Definition of /// function is auto generated by tblgen. From 870ca74b704ad51cf4be17b8e4145e93190f5b99 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Wed, 1 Nov 2023 21:51:51 -0400 Subject: [PATCH 022/111] add builtin --- llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index b93a5e7be1b51..5e0edea642ae8 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -77,6 +77,10 @@ def int_wasm_table_fill_funcref : [llvm_table_ty, llvm_i32_ty, llvm_funcref_ty, llvm_i32_ty], []>; +def int_wasm_memory_randomtag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], + [llvm_ptr_ty], []>; + //===----------------------------------------------------------------------===// // Trapping float-to-int conversions //===----------------------------------------------------------------------===// From 3ab574e5e7aa0b3f45f0db2d1a56207e0369be5e Mon Sep 17 00:00:00 2001 From: trcrsired Date: Wed, 1 Nov 2023 21:57:07 -0400 Subject: [PATCH 023/111] try to add memory.randomtag instruction for webassembly --- .../Target/WebAssembly/WebAssemblyInstrMemory.td | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td index 01c0909af72e5..7210ce1f1527b 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td @@ -193,3 +193,16 @@ defm MEMORY_GROW_A#B : I<(outs rc:$dst), (ins i32imm:$flags, rc:$delta), defm : MemoryOps; defm : MemoryOps; + +multiclass MemoryTags { + +// Memtag generate tag. +defm MEMORY_RANDOMTAG_A#B : I<(outs rc:$dst), (ins rc:$addr), + (outs), (ins rc:$addr), + [(set rc:$dst, + (int_wasm_memory_randomtag (rc:$addr)))], + "memory.randomtag\t$dst", + "memory.randomtag\t$addr",0x41>; + + +} From 6932c113c4c67fde46037d565edc96d583057f1a Mon Sep 17 00:00:00 2001 From: trcrsired Date: Mon, 6 Nov 2023 22:07:16 -0500 Subject: [PATCH 024/111] Add BI_builtin_wasm_memory_tag definition Attempt to emit LLVM IR for it --- clang/include/clang/Basic/BuiltinsWebAssembly.def | 3 +++ clang/lib/CodeGen/CGBuiltin.cpp | 4 ++++ 2 files changed, 7 insertions(+) diff --git a/clang/include/clang/Basic/BuiltinsWebAssembly.def b/clang/include/clang/Basic/BuiltinsWebAssembly.def index 7e950914ad946..dbb9d3401a5c3 100644 --- a/clang/include/clang/Basic/BuiltinsWebAssembly.def +++ b/clang/include/clang/Basic/BuiltinsWebAssembly.def @@ -25,6 +25,9 @@ BUILTIN(__builtin_wasm_memory_size, "zIi", "n") BUILTIN(__builtin_wasm_memory_grow, "zIiz", "n") +// Memory Tagging +BUILTIN(__builtin_wasm_memory_randomtag, "v*v*", "n") + // Thread-local storage TARGET_BUILTIN(__builtin_wasm_tls_size, "z", "nc", "bulk-memory") TARGET_BUILTIN(__builtin_wasm_tls_align, "z", "nc", "bulk-memory") diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 978f6ffd14574..bc2cb4de25983 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -20335,6 +20335,10 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, return Builder.CreateCall(Callee, {TableX, TableY, SrcIdx, DstIdx, NElems}); } + case WebAssembly::BI__builtin_wasm_memory_randomtag: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomtag); + return Builder.CreateCall(Callee); + } default: return nullptr; } From 9de8b7d537b06f785851ccd4dcf1e3d9c5a80d64 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Wed, 29 Nov 2023 11:46:05 -0500 Subject: [PATCH 025/111] Correctly emits the IR for __builtin_wasm_memory_randomtag --- clang/lib/CodeGen/CGBuiltin.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 353326d932dfe..bfbac4ab7491e 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -20480,7 +20480,8 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, } case WebAssembly::BI__builtin_wasm_memory_randomtag: { Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomtag); - return Builder.CreateCall(Callee); + Value *Ptr = EmitScalarExpr(E->getArg(0)); + return Builder.CreateCall(Callee, {Ptr}); } default: return nullptr; From e59282f1aeab490be312736d0f264ac138753401 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Mon, 4 Dec 2023 15:49:22 -0500 Subject: [PATCH 026/111] remove memory random tag --- .../Target/WebAssembly/WebAssemblyInstrMemory.td | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td index 7210ce1f1527b..01c0909af72e5 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemory.td @@ -193,16 +193,3 @@ defm MEMORY_GROW_A#B : I<(outs rc:$dst), (ins i32imm:$flags, rc:$delta), defm : MemoryOps; defm : MemoryOps; - -multiclass MemoryTags { - -// Memtag generate tag. -defm MEMORY_RANDOMTAG_A#B : I<(outs rc:$dst), (ins rc:$addr), - (outs), (ins rc:$addr), - [(set rc:$dst, - (int_wasm_memory_randomtag (rc:$addr)))], - "memory.randomtag\t$dst", - "memory.randomtag\t$addr",0x41>; - - -} From e5a2809e670fa02f36141e55d89e1353d34aec9d Mon Sep 17 00:00:00 2001 From: trcrsired Date: Mon, 4 Dec 2023 18:37:12 -0500 Subject: [PATCH 027/111] changing table gen for webassemblyinstr --- .../WebAssembly/WebAssemblyInstrInfo.td | 1 + .../WebAssembly/WebAssemblyInstrMemtag.td | 20 +++++++++++++++++++ 2 files changed, 21 insertions(+) create mode 100644 llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td index cc5109c8c12d0..c6327aebddba4 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td @@ -444,3 +444,4 @@ include "WebAssemblyInstrSIMD.td" include "WebAssemblyInstrRef.td" include "WebAssemblyInstrBulkMemory.td" include "WebAssemblyInstrTable.td" +// include "WebAssemblyInstrMemtag.td" diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td new file mode 100644 index 0000000000000..bb7149f690b07 --- /dev/null +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -0,0 +1,20 @@ +// WebAssemblyInstrMemtag.td - WebAssembly Memtag codegen support -*- memtaggen -*- +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// WebAssembly Mem Table operand code-gen constructs. +/// Instructions that handle memtags +//===----------------------------------------------------------------------===// + +defm MEMORY_RANDOMTAG : I<(outs I64:$res), (ins table32_op:$src), + (outs), (ins), + [(int_wasm_memory_randomtag (WebAssemblyWrapper tglobaladdr:$table))], + "memory.randomtag\t$res", + "memory.randomtag\t", + 0xfc12, true>, + Requires<[HasReferenceTypes]>; From 6c0a7fa58dd221534eb9582e90f197b98215ce6e Mon Sep 17 00:00:00 2001 From: trcrsired Date: Wed, 6 Dec 2023 16:57:54 -0500 Subject: [PATCH 028/111] attempt to correctly define webassemblyinstrmemtag --- llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index bb7149f690b07..8fee7967355b2 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -11,10 +11,10 @@ /// Instructions that handle memtags //===----------------------------------------------------------------------===// -defm MEMORY_RANDOMTAG : I<(outs I64:$res), (ins table32_op:$src), +defm MEMORY_RANDOMTAG: I<(outs I64:$dst), (ins I64:$src), (outs), (ins), - [(int_wasm_memory_randomtag (WebAssemblyWrapper tglobaladdr:$table))], - "memory.randomtag\t$res", + [(set I64:$dst, + (int_wasm_memory_randomtag (WebAssemblyWrapper I64:$src)))], + "memory.randomtag\t$dst, $src", "memory.randomtag\t", - 0xfc12, true>, - Requires<[HasReferenceTypes]>; + 0xfc12, true>; From 3af3790eb963abfde4eec3ac5dfcf70b8fac8c84 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Wed, 6 Dec 2023 17:11:40 -0500 Subject: [PATCH 029/111] uncomment webassemblyinstrmemtag.td in WebAssemblyInstrInfo.td --- llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td index c6327aebddba4..74ebce2c8e70e 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td @@ -444,4 +444,4 @@ include "WebAssemblyInstrSIMD.td" include "WebAssemblyInstrRef.td" include "WebAssemblyInstrBulkMemory.td" include "WebAssemblyInstrTable.td" -// include "WebAssemblyInstrMemtag.td" +include "WebAssemblyInstrMemtag.td" From 7ab018a65075e87db765b054d8b4c0af3e35472b Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 7 Dec 2023 18:22:22 -0500 Subject: [PATCH 030/111] fix the pattern of instr memtag --- llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 11 +++++++---- llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td | 2 +- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index 5e0edea642ae8..82891ead3dfe6 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -77,10 +77,6 @@ def int_wasm_table_fill_funcref : [llvm_table_ty, llvm_i32_ty, llvm_funcref_ty, llvm_i32_ty], []>; -def int_wasm_memory_randomtag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], - [llvm_ptr_ty], []>; - //===----------------------------------------------------------------------===// // Trapping float-to-int conversions //===----------------------------------------------------------------------===// @@ -345,4 +341,11 @@ def int_wasm_tls_base : [], [IntrReadMem]>; +//===----------------------------------------------------------------------===// +// Memory Tagging intrinsics +//===----------------------------------------------------------------------===// + +def int_wasm_memory_randomtag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty], [], "llvm.wasm.memory.randomtag">; + } // TargetPrefix = "wasm" diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 8fee7967355b2..4558c0dfeb80b 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -14,7 +14,7 @@ defm MEMORY_RANDOMTAG: I<(outs I64:$dst), (ins I64:$src), (outs), (ins), [(set I64:$dst, - (int_wasm_memory_randomtag (WebAssemblyWrapper I64:$src)))], + (int_wasm_memory_randomtag I64:$src))], "memory.randomtag\t$dst, $src", "memory.randomtag\t", 0xfc12, true>; From 1766c4cb933b5fab914d62a78ecf2889519fab72 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 7 Dec 2023 19:11:26 -0500 Subject: [PATCH 031/111] support both 32 bit and 64 bit of memorytaggingops --- .../Target/WebAssembly/WebAssemblyInstrMemtag.td | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 4558c0dfeb80b..8e76b16732426 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -11,10 +11,17 @@ /// Instructions that handle memtags //===----------------------------------------------------------------------===// -defm MEMORY_RANDOMTAG: I<(outs I64:$dst), (ins I64:$src), +multiclass MemoryTaggingOps { + +defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins rc:$src), (outs), (ins), - [(set I64:$dst, - (int_wasm_memory_randomtag I64:$src))], + [(set rc:$dst, + (int_wasm_memory_randomtag rc:$src))], "memory.randomtag\t$dst, $src", "memory.randomtag\t", 0xfc12, true>; + +} + +defm : MemoryTaggingOps; +defm : MemoryTaggingOps; From 47b8aabdc60427093530369b264222571ea4d979 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 7 Dec 2023 19:36:33 -0500 Subject: [PATCH 032/111] add a test to memory-randomtag.ll --- .../CodeGen/WebAssembly/memory-randomtag.ll | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 llvm/test/CodeGen/WebAssembly/memory-randomtag.ll diff --git a/llvm/test/CodeGen/WebAssembly/memory-randomtag.ll b/llvm/test/CodeGen/WebAssembly/memory-randomtag.ll new file mode 100644 index 0000000000000..15932061abf5f --- /dev/null +++ b/llvm/test/CodeGen/WebAssembly/memory-randomtag.ll @@ -0,0 +1,18 @@ +; RUN: llc < %s -asm-verbose=false | FileCheck %s + +; Test memory tagging builtin on wasm64 + +target triple = "wasm64-unknown-unknown" + +; CHECK-LABEL: memory_randomtag: +; CHECK-NEXT: .functype memory_randomtag (i64) -> (i64) +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: memory.randomtag +; CHECK-NEXT: end_function +define ptr @memory_randomtag(ptr %p) { + %1 = call ptr @llvm.wasm.memory.randomtag(ptr %p) + ret ptr %1 +} + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn +declare ptr @llvm.wasm.memory.randomtag(ptr) From 0362405aaa73e86401068711d52e5bf480201e84 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 7 Dec 2023 21:04:16 -0500 Subject: [PATCH 033/111] add other memory tagging instructions --- llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 9 +++++++ .../WebAssembly/WebAssemblyInstrMemtag.td | 24 ++++++++++++++++++- 2 files changed, 32 insertions(+), 1 deletion(-) diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index 82891ead3dfe6..a9cbe9dac6695 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -348,4 +348,13 @@ def int_wasm_tls_base : def int_wasm_memory_randomtag : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty], [], "llvm.wasm.memory.randomtag">; +def int_wasm_memory_loadtag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty], [], "llvm.wasm.memory.loadtag">; + +def int_wasm_memory_storetag : + DefaultAttrsIntrinsic<[], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storetag">; + +def int_wasm_memory_storeztag : + DefaultAttrsIntrinsic<[], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storeztag">; + } // TargetPrefix = "wasm" diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 8e76b16732426..eff9d98c2d33a 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -19,7 +19,29 @@ defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins rc:$src), (int_wasm_memory_randomtag rc:$src))], "memory.randomtag\t$dst, $src", "memory.randomtag\t", - 0xfc12, true>; + 0xfc12>; + +defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins rc:$src), + (outs), (ins), + [(set rc:$taggedptr, + (int_wasm_memory_loadtag rc:$src))], + "memory.loadtag\t$taggedptr, $src", + "memory.loadtag\t", + 0xfc13>; + +defm MEMORY_STORETAG_A#B: I<(outs), (ins rc:$src rc:$b16), + (outs), (ins), + [(int_wasm_memory_storetag rc:$src rc:$b16)], + "memory.storetag\t$src, $b16", + "memory.storetag\t", + 0xfc14>; + +defm MEMORY_STOREZTAG_A#B: I<(outs), (ins rc:$src rc:$b16), + (outs), (ins), + [(int_wasm_memory_storeztag rc:$src rc:$b16)], + "memory.storeztag\t$src, $b16", + "memory.storeztag\t", + 0xfc15>; } From 3eace819670ff987e65de761fb4b3e2711350b39 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 7 Dec 2023 21:09:47 -0500 Subject: [PATCH 034/111] Add __builtin_wasm_memory_loadtag, __builtin_wasm_memory_storetag and __builtin_wasm_memory_storeztag --- clang/include/clang/Basic/BuiltinsWebAssembly.def | 3 +++ 1 file changed, 3 insertions(+) diff --git a/clang/include/clang/Basic/BuiltinsWebAssembly.def b/clang/include/clang/Basic/BuiltinsWebAssembly.def index dbb9d3401a5c3..df56a0de0d426 100644 --- a/clang/include/clang/Basic/BuiltinsWebAssembly.def +++ b/clang/include/clang/Basic/BuiltinsWebAssembly.def @@ -27,6 +27,9 @@ BUILTIN(__builtin_wasm_memory_grow, "zIiz", "n") // Memory Tagging BUILTIN(__builtin_wasm_memory_randomtag, "v*v*", "n") +BUILTIN(__builtin_wasm_memory_loadtag, "v*v*", "n") +BUILTIN(__builtin_wasm_memory_storetag, "vv*z", "n") +BUILTIN(__builtin_wasm_memory_storeztag, "vv*z", "n") // Thread-local storage TARGET_BUILTIN(__builtin_wasm_tls_size, "z", "nc", "bulk-memory") From 3295340a3fd3ad7c01c26148215dab1e440b1966 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 8 Dec 2023 10:11:02 -0500 Subject: [PATCH 035/111] Fix the syntax issue with WebAssemblyInstrMemtag --- llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index eff9d98c2d33a..81de471a82314 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -29,16 +29,16 @@ defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins rc:$src), "memory.loadtag\t", 0xfc13>; -defm MEMORY_STORETAG_A#B: I<(outs), (ins rc:$src rc:$b16), +defm MEMORY_STORETAG_A#B: I<(outs), (ins rc:$src, rc:$b16), (outs), (ins), - [(int_wasm_memory_storetag rc:$src rc:$b16)], + [(int_wasm_memory_storetag rc:$src, rc:$b16)], "memory.storetag\t$src, $b16", "memory.storetag\t", 0xfc14>; -defm MEMORY_STOREZTAG_A#B: I<(outs), (ins rc:$src rc:$b16), +defm MEMORY_STOREZTAG_A#B: I<(outs), (ins rc:$src, rc:$b16), (outs), (ins), - [(int_wasm_memory_storeztag rc:$src rc:$b16)], + [(int_wasm_memory_storeztag rc:$src, rc:$b16)], "memory.storeztag\t$src, $b16", "memory.storeztag\t", 0xfc15>; From 6f6c86c4dca3719fb65faf4a8069826af96fcd09 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 8 Dec 2023 13:21:19 -0500 Subject: [PATCH 036/111] Add memory.copytag and memory.subtag instructions for wasm --- .../clang/Basic/BuiltinsWebAssembly.def | 2 ++ llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 10 ++++++-- .../WebAssembly/WebAssemblyInstrMemtag.td | 24 +++++++++++++++---- 3 files changed, 30 insertions(+), 6 deletions(-) diff --git a/clang/include/clang/Basic/BuiltinsWebAssembly.def b/clang/include/clang/Basic/BuiltinsWebAssembly.def index df56a0de0d426..78bdf510695c5 100644 --- a/clang/include/clang/Basic/BuiltinsWebAssembly.def +++ b/clang/include/clang/Basic/BuiltinsWebAssembly.def @@ -27,6 +27,8 @@ BUILTIN(__builtin_wasm_memory_grow, "zIiz", "n") // Memory Tagging BUILTIN(__builtin_wasm_memory_randomtag, "v*v*", "n") +BUILTIN(__builtin_wasm_memory_copytag, "v*v*v*", "n") +BUILTIN(__builtin_wasm_memory_subtag, "Yv*v*", "n") BUILTIN(__builtin_wasm_memory_loadtag, "v*v*", "n") BUILTIN(__builtin_wasm_memory_storetag, "vv*z", "n") BUILTIN(__builtin_wasm_memory_storeztag, "vv*z", "n") diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index a9cbe9dac6695..3e303a3e2636e 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -346,10 +346,16 @@ def int_wasm_tls_base : //===----------------------------------------------------------------------===// def int_wasm_memory_randomtag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty], [], "llvm.wasm.memory.randomtag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.randomtag">; + +def int_wasm_memory_copytag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.copytag",>; + +def int_wasm_memory_subtag : + DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.subtag">; def int_wasm_memory_loadtag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty], [], "llvm.wasm.memory.loadtag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty], [IntrReadMem], "llvm.wasm.memory.loadtag">; def int_wasm_memory_storetag : DefaultAttrsIntrinsic<[], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storetag">; diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 81de471a82314..0c3947ff00c3a 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -19,7 +19,23 @@ defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins rc:$src), (int_wasm_memory_randomtag rc:$src))], "memory.randomtag\t$dst, $src", "memory.randomtag\t", - 0xfc12>; + 0xfc20>; + +defm MEMORY_COPYTAG_A#B: I<(outs rc:$dstwsrctag), (ins rc:$dst, rc:$src), + (outs), (ins), + [(set rc:$dstwsrctag, + (int_wasm_memory_copytag rc:$dst, rc:$src))], + "memory.copytag\t$dstwsrctag, $dst, $src", + "memory.copytag\t", + 0xfc21>; + +defm MEMORY_SUBTAG_A#B: I<(outs rc:$diff), (ins rc:$minuendptr, rc:$subtrahendptr), + (outs), (ins), + [(set rc:$diff, + (int_wasm_memory_subtag rc:$minuendptr, rc:$subtrahendptr))], + "memory.subtag\t$diff, $minuendptr, $subtrahendptr", + "memory.subtag\t", + 0xfc22>; defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins rc:$src), (outs), (ins), @@ -27,21 +43,21 @@ defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins rc:$src), (int_wasm_memory_loadtag rc:$src))], "memory.loadtag\t$taggedptr, $src", "memory.loadtag\t", - 0xfc13>; + 0xfc23>; defm MEMORY_STORETAG_A#B: I<(outs), (ins rc:$src, rc:$b16), (outs), (ins), [(int_wasm_memory_storetag rc:$src, rc:$b16)], "memory.storetag\t$src, $b16", "memory.storetag\t", - 0xfc14>; + 0xfc24>; defm MEMORY_STOREZTAG_A#B: I<(outs), (ins rc:$src, rc:$b16), (outs), (ins), [(int_wasm_memory_storeztag rc:$src, rc:$b16)], "memory.storeztag\t$src, $b16", "memory.storeztag\t", - 0xfc15>; + 0xfc25>; } From ba54e523c3ffd69276a9e9b0ac4d134de4f931e1 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 8 Dec 2023 13:23:12 -0500 Subject: [PATCH 037/111] Fix IntrinsicsWebAssembly.td --- llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index 3e303a3e2636e..c28fd164eddb7 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -349,7 +349,7 @@ def int_wasm_memory_randomtag : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.randomtag">; def int_wasm_memory_copytag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.copytag",>; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.copytag">; def int_wasm_memory_subtag : DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.subtag">; From 18af1ebb6f1d95dd02ece4c53f5948d80870be50 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 8 Dec 2023 13:51:02 -0500 Subject: [PATCH 038/111] add a placeholder implementation for clang wasm memorytag builtins --- clang/lib/CodeGen/CGBuiltin.cpp | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 2b5ff703d45f3..693bcea23b571 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -20523,6 +20523,36 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, Value *Ptr = EmitScalarExpr(E->getArg(0)); return Builder.CreateCall(Callee, {Ptr}); } + case WebAssembly::BI__builtin_wasm_memory_copytag: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_copytag); + Value *Ptr0 = EmitScalarExpr(E->getArg(0)); + Value *Ptr1 = EmitScalarExpr(E->getArg(1)); + return Builder.CreateCall(Callee, {Ptr0, Ptr1}); + } + case WebAssembly::BI__builtin_wasm_memory_subtag: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_subtag); + Value *Ptr0 = EmitScalarExpr(E->getArg(0)); + Value *Ptr1 = EmitScalarExpr(E->getArg(1)); + return Builder.CreateCall(Callee, {Ptr0, Ptr1}); + } + case WebAssembly::BI__builtin_wasm_memory_loadtag: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_loadtag); + Value *Ptr0 = EmitScalarExpr(E->getArg(0)); + Value *Ptr1 = EmitScalarExpr(E->getArg(1)); + return Builder.CreateCall(Callee, {Ptr0, Ptr1}); + } + case WebAssembly::BI__builtin_wasm_memory_storetag: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storetag); + Value *Ptr = EmitScalarExpr(E->getArg(0)); + Value *B16 = EmitScalarExpr(E->getArg(1)); + return Builder.CreateCall(Callee, {Ptr, B16}); + } + case WebAssembly::BI__builtin_wasm_memory_storeztag: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storeztag); + Value *Ptr = EmitScalarExpr(E->getArg(0)); + Value *B16 = EmitScalarExpr(E->getArg(1)); + return Builder.CreateCall(Callee, {Ptr, B16}); + } default: return nullptr; } From 38a5dca5eb0a121e7e423b965b957b23b76b7762 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 8 Dec 2023 14:30:24 -0500 Subject: [PATCH 039/111] Add memory.store1tag and memory.storez1tag instruction for wasm --- clang/include/clang/Basic/BuiltinsWebAssembly.def | 2 ++ clang/lib/CodeGen/CGBuiltin.cpp | 12 ++++++++++++ llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 6 ++++++ .../Target/WebAssembly/WebAssemblyInstrMemtag.td | 14 ++++++++++++++ 4 files changed, 34 insertions(+) diff --git a/clang/include/clang/Basic/BuiltinsWebAssembly.def b/clang/include/clang/Basic/BuiltinsWebAssembly.def index 78bdf510695c5..679e9b2e0dfc2 100644 --- a/clang/include/clang/Basic/BuiltinsWebAssembly.def +++ b/clang/include/clang/Basic/BuiltinsWebAssembly.def @@ -32,6 +32,8 @@ BUILTIN(__builtin_wasm_memory_subtag, "Yv*v*", "n") BUILTIN(__builtin_wasm_memory_loadtag, "v*v*", "n") BUILTIN(__builtin_wasm_memory_storetag, "vv*z", "n") BUILTIN(__builtin_wasm_memory_storeztag, "vv*z", "n") +BUILTIN(__builtin_wasm_memory_store1tag, "vv*z", "n") +BUILTIN(__builtin_wasm_memory_storez1tag, "vv*z", "n") // Thread-local storage TARGET_BUILTIN(__builtin_wasm_tls_size, "z", "nc", "bulk-memory") diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 693bcea23b571..d323b5997d22a 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -20553,6 +20553,18 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, Value *B16 = EmitScalarExpr(E->getArg(1)); return Builder.CreateCall(Callee, {Ptr, B16}); } + case WebAssembly::BI__builtin_wasm_memory_store1tag: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_store1tag); + Value *Ptr = EmitScalarExpr(E->getArg(0)); + Value *B16 = EmitScalarExpr(E->getArg(1)); + return Builder.CreateCall(Callee, {Ptr, B16}); + } + case WebAssembly::BI__builtin_wasm_memory_storeztag: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storez1tag); + Value *Ptr = EmitScalarExpr(E->getArg(0)); + Value *B16 = EmitScalarExpr(E->getArg(1)); + return Builder.CreateCall(Callee, {Ptr, B16}); + } default: return nullptr; } diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index c28fd164eddb7..1e779d6b7349e 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -363,4 +363,10 @@ def int_wasm_memory_storetag : def int_wasm_memory_storeztag : DefaultAttrsIntrinsic<[], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storeztag">; +def int_wasm_memory_store1tag : + DefaultAttrsIntrinsic<[], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.store1tag">; + +def int_wasm_memory_storez1tag : + DefaultAttrsIntrinsic<[], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storez1tag">; + } // TargetPrefix = "wasm" diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 0c3947ff00c3a..3afafeae2cadb 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -59,6 +59,20 @@ defm MEMORY_STOREZTAG_A#B: I<(outs), (ins rc:$src, rc:$b16), "memory.storeztag\t", 0xfc25>; +defm MEMORY_STORE1TAG_A#B: I<(outs), (ins rc:$src, rc:$b16), + (outs), (ins), + [(int_wasm_memory_store1tag rc:$src, rc:$b16)], + "memory.store1tag\t$src, $b16", + "memory.storetag\t", + 0xfc26>; + +defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins rc:$src, rc:$b16), + (outs), (ins), + [(int_wasm_memory_storez1tag rc:$src, rc:$b16)], + "memory.storez1tag\t$src, $b16", + "memory.storez1tag\t", + 0xfc27>; + } defm : MemoryTaggingOps; From 2d5b4d2beb63f8fad3a2dfc080705421277010d4 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 8 Dec 2023 14:33:23 -0500 Subject: [PATCH 040/111] fix type issue for wasm.memory.store1tag instruction --- llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 3afafeae2cadb..5cc3da65767b3 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -63,7 +63,7 @@ defm MEMORY_STORE1TAG_A#B: I<(outs), (ins rc:$src, rc:$b16), (outs), (ins), [(int_wasm_memory_store1tag rc:$src, rc:$b16)], "memory.store1tag\t$src, $b16", - "memory.storetag\t", + "memory.store1tag\t", 0xfc26>; defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins rc:$src, rc:$b16), From 4cddd25718ad193543f53e37d6c75c2252d94632 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 8 Dec 2023 16:02:15 -0500 Subject: [PATCH 041/111] fix typo error for BI__builtin_wasm_memory_storez1tag --- clang/lib/CodeGen/CGBuiltin.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index d323b5997d22a..a5dfc8e2895ab 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -20559,7 +20559,7 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, Value *B16 = EmitScalarExpr(E->getArg(1)); return Builder.CreateCall(Callee, {Ptr, B16}); } - case WebAssembly::BI__builtin_wasm_memory_storeztag: { + case WebAssembly::BI__builtin_wasm_memory_storez1tag: { Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storez1tag); Value *Ptr = EmitScalarExpr(E->getArg(0)); Value *B16 = EmitScalarExpr(E->getArg(1)); From ae5f737b4844df078c3d38f934b5afcb1107bce4 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 8 Dec 2023 16:30:06 -0500 Subject: [PATCH 042/111] Fix calls of __builtin_wasm_memory_loadtag --- clang/lib/CodeGen/CGBuiltin.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index a5dfc8e2895ab..7f3912c415219 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -20538,8 +20538,7 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, case WebAssembly::BI__builtin_wasm_memory_loadtag: { Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_loadtag); Value *Ptr0 = EmitScalarExpr(E->getArg(0)); - Value *Ptr1 = EmitScalarExpr(E->getArg(1)); - return Builder.CreateCall(Callee, {Ptr0, Ptr1}); + return Builder.CreateCall(Callee, {Ptr0}); } case WebAssembly::BI__builtin_wasm_memory_storetag: { Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storetag); From f5a1aaefc2470a52c0f0005a8fd8dc8210ba802d Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 8 Dec 2023 18:40:04 -0500 Subject: [PATCH 043/111] Change the test of memory-randomtag to a general memory-memtag --- .../test/CodeGen/WebAssembly/memory-memtag.ll | 115 ++++++++++++++++++ .../CodeGen/WebAssembly/memory-randomtag.ll | 18 --- 2 files changed, 115 insertions(+), 18 deletions(-) create mode 100644 llvm/test/CodeGen/WebAssembly/memory-memtag.ll delete mode 100644 llvm/test/CodeGen/WebAssembly/memory-randomtag.ll diff --git a/llvm/test/CodeGen/WebAssembly/memory-memtag.ll b/llvm/test/CodeGen/WebAssembly/memory-memtag.ll new file mode 100644 index 0000000000000..a0147fdecbc85 --- /dev/null +++ b/llvm/test/CodeGen/WebAssembly/memory-memtag.ll @@ -0,0 +1,115 @@ +; RUN: llc < %s -asm-verbose=false | FileCheck %s + +; Test memory tagging builtin on wasm64 + +target triple = "wasm64-unknown-unknown" + +; CHECK-LABEL: memory_randomtag: +; CHECK-NEXT: .functype memory_randomtag (i64) -> (i64) +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: memory.randomtag +; CHECK-NEXT: end_function +define ptr @memory_randomtag(ptr %p) { + %1 = call ptr @llvm.wasm.memory.randomtag(ptr %p) + ret ptr %1 +} + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn +declare ptr @llvm.wasm.memory.randomtag(ptr) + +; CHECK-LABEL: memory_copytag: +; CHECK-NEXT: .functype memory_copytag (i64, i64) -> (i64) +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: local.get 1 +; CHECK-NEXT: memory.copytag +; CHECK-NEXT: end_function +define ptr @memory_copytag(ptr %p0, ptr %p1) { + %1 = call ptr @llvm.wasm.memory.copytag(ptr %p0, ptr %p1) + ret ptr %1 +} + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn +declare ptr @llvm.wasm.memory.copytag(ptr, ptr) + +; CHECK-LABEL: memory_subtag: +; CHECK-NEXT: .functype memory_subtag (i64, i64) -> (i64) +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: local.get 1 +; CHECK-NEXT: memory.subtag +; CHECK-NEXT: end_function +define i64 @memory_subtag(ptr %p0, ptr %p1) { + %1 = call i64 @llvm.wasm.memory.subtag(ptr %p0, ptr %p1) + ret i64 %1 +} + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn +declare i64 @llvm.wasm.memory.subtag(ptr, ptr) + +; CHECK-LABEL: memory_loadtag: +; CHECK-NEXT: .functype memory_loadtag (i64) -> (i64) +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: memory.loadtag +; CHECK-NEXT: end_function +define ptr @memory_loadtag(ptr %p0) { + %1 = call ptr @llvm.wasm.memory.loadtag(ptr %p0) + ret ptr %1 +} + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn +declare ptr @llvm.wasm.memory.loadtag(ptr) + +; CHECK-LABEL: memory_storetag: +; CHECK-NEXT: .functype memory_storetag (i64, i64) -> () +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: local.get 1 +; CHECK-NEXT: memory.storetag +; CHECK-NEXT: end_function +define void @memory_storetag(ptr %p0, i64 %b16) { + call void @llvm.wasm.memory.storetag(ptr %p0, i64 %b16) + ret void +} + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn +declare void @llvm.wasm.memory.storetag(ptr, i64) + +; CHECK-LABEL: memory_storeztag: +; CHECK-NEXT: .functype memory_storeztag (i64, i64) -> () +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: local.get 1 +; CHECK-NEXT: memory.storeztag +; CHECK-NEXT: end_function +define void @memory_storeztag(ptr %p0, i64 %b16) { + call void @llvm.wasm.memory.storeztag(ptr %p0, i64 %b16) + ret void +} + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn +declare void @llvm.wasm.memory.storeztag(ptr, i64) + +; CHECK-LABEL: memory_store1tag: +; CHECK-NEXT: .functype memory_store1tag (i64, i64) -> () +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: local.get 1 +; CHECK-NEXT: memory.store1tag +; CHECK-NEXT: end_function +define void @memory_store1tag(ptr %p0, i64 %b16) { + call void @llvm.wasm.memory.store1tag(ptr %p0, i64 %b16) + ret void +} + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn +declare void @llvm.wasm.memory.store1tag(ptr, i64) + +; CHECK-LABEL: memory_storez1tag: +; CHECK-NEXT: .functype memory_storez1tag (i64, i64) -> () +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: local.get 1 +; CHECK-NEXT: memory.storez1tag +; CHECK-NEXT: end_function +define void @memory_storez1tag(ptr %p0, i64 %b16) { + call void @llvm.wasm.memory.storez1tag(ptr %p0, i64 %b16) + ret void +} + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn +declare void @llvm.wasm.memory.storez1tag(ptr, i64) diff --git a/llvm/test/CodeGen/WebAssembly/memory-randomtag.ll b/llvm/test/CodeGen/WebAssembly/memory-randomtag.ll deleted file mode 100644 index 15932061abf5f..0000000000000 --- a/llvm/test/CodeGen/WebAssembly/memory-randomtag.ll +++ /dev/null @@ -1,18 +0,0 @@ -; RUN: llc < %s -asm-verbose=false | FileCheck %s - -; Test memory tagging builtin on wasm64 - -target triple = "wasm64-unknown-unknown" - -; CHECK-LABEL: memory_randomtag: -; CHECK-NEXT: .functype memory_randomtag (i64) -> (i64) -; CHECK-NEXT: local.get 0 -; CHECK-NEXT: memory.randomtag -; CHECK-NEXT: end_function -define ptr @memory_randomtag(ptr %p) { - %1 = call ptr @llvm.wasm.memory.randomtag(ptr %p) - ret ptr %1 -} - -; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn -declare ptr @llvm.wasm.memory.randomtag(ptr) From beb7062ac0b2f0dc30962909c17993f9b98feb3f Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 8 Dec 2023 19:42:13 -0500 Subject: [PATCH 044/111] fix WebAssembly Memtag builtins --- clang/lib/CodeGen/CGBuiltin.cpp | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 7f3912c415219..3c5feae59a96a 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -20530,38 +20530,38 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, return Builder.CreateCall(Callee, {Ptr0, Ptr1}); } case WebAssembly::BI__builtin_wasm_memory_subtag: { - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_subtag); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_subtag, ConvertType(E->getType())); Value *Ptr0 = EmitScalarExpr(E->getArg(0)); Value *Ptr1 = EmitScalarExpr(E->getArg(1)); return Builder.CreateCall(Callee, {Ptr0, Ptr1}); } case WebAssembly::BI__builtin_wasm_memory_loadtag: { Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_loadtag); - Value *Ptr0 = EmitScalarExpr(E->getArg(0)); - return Builder.CreateCall(Callee, {Ptr0}); + Value *Ptr = EmitScalarExpr(E->getArg(0)); + return Builder.CreateCall(Callee, {Ptr}); } case WebAssembly::BI__builtin_wasm_memory_storetag: { - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storetag); Value *Ptr = EmitScalarExpr(E->getArg(0)); Value *B16 = EmitScalarExpr(E->getArg(1)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storetag, B16->getType()); return Builder.CreateCall(Callee, {Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_storeztag: { - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storeztag); Value *Ptr = EmitScalarExpr(E->getArg(0)); Value *B16 = EmitScalarExpr(E->getArg(1)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storeztag, B16->getType()); return Builder.CreateCall(Callee, {Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_store1tag: { - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_store1tag); Value *Ptr = EmitScalarExpr(E->getArg(0)); Value *B16 = EmitScalarExpr(E->getArg(1)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_store1tag, B16->getType()); return Builder.CreateCall(Callee, {Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_storez1tag: { - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storez1tag); Value *Ptr = EmitScalarExpr(E->getArg(0)); Value *B16 = EmitScalarExpr(E->getArg(1)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storez1tag, B16->getType()); return Builder.CreateCall(Callee, {Ptr, B16}); } default: From 91a3e84927b8710c00b5817864f10f1850b36111 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 8 Dec 2023 20:06:39 -0500 Subject: [PATCH 045/111] add a test for wasm-builtin-memtag --- .../CodeGen/WebAssembly/builtins-memtag.c | 83 +++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 clang/test/CodeGen/WebAssembly/builtins-memtag.c diff --git a/clang/test/CodeGen/WebAssembly/builtins-memtag.c b/clang/test/CodeGen/WebAssembly/builtins-memtag.c new file mode 100644 index 0000000000000..c6327b0a6b70b --- /dev/null +++ b/clang/test/CodeGen/WebAssembly/builtins-memtag.c @@ -0,0 +1,83 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature +// RUN: %clang_cc1 -triple wasm64 -fsanitize=memtag -target-feature +reference-types -disable-O0-optnone -O3 -emit-llvm %s -o - | opt -S -passes=mem2reg | FileCheck %s +// REQUIRES: webassembly-registered-target + +// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_randomtag +// CHECK-SAME: (ptr noundef readnone [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: entry: +// CHECK-NEXT: [[TMP0:%.*]] = {{[^@]+}}call ptr @llvm.wasm.memory.randomtag(ptr [[INDEX:%.*]]) +// CHECK-NEXT: ret ptr %0 +// +void* test_builtin_wasm_memory_randomtag(void *p) { + return __builtin_wasm_memory_randomtag(p); +} + +// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_copytag +// CHECK-SAME: (ptr noundef readnone [[INDEX:%.*]], ptr noundef readnone [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: entry: +// CHECK-NEXT: [[TMP0:%.*]] = {{[^@]+}}call ptr @llvm.wasm.memory.copytag(ptr [[INDEX:%.*]], ptr [[INDEX:%.*]]) +// CHECK-NEXT: ret ptr %0 +// +void* test_builtin_wasm_memory_copytag(void *p1, void *p2) { + return __builtin_wasm_memory_copytag(p1, p2); +} + +// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_subtag +// CHECK-SAME: (ptr noundef readnone [[INDEX:%.*]], ptr noundef readnone [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: entry: +// CHECK-NEXT: [[TMP0:%.*]] = {{[^@]+}}call i64 @llvm.wasm.memory.subtag.i64(ptr [[INDEX:%.*]], ptr [[INDEX:%.*]]) +// CHECK-NEXT: ret i64 %0 +// +__PTRDIFF_TYPE__ test_builtin_wasm_memory_subtag(void *p1, void *p2) { + return __builtin_wasm_memory_subtag(p1, p2); +} + +// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_loadtag +// CHECK-SAME: (ptr noundef readonly [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: entry: +// CHECK-NEXT: [[TMP0:%.*]] = {{[^@]+}}call ptr @llvm.wasm.memory.loadtag(ptr [[INDEX:%.*]]) +// CHECK-NEXT: ret ptr %0 +// +void* test_builtin_wasm_memory_loadtag(void *p) { + return __builtin_wasm_memory_loadtag(p); +} + +// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_storetag +// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: entry: +// CHECK-NEXT: {{[^@]+}}call void @llvm.wasm.memory.storetag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) +// CHECK-NEXT: ret void +// +void test_builtin_wasm_memory_storetag(void *p, __SIZE_TYPE__ b16) { + __builtin_wasm_memory_storetag(p, b16); +} + +// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_storeztag +// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: entry: +// CHECK-NEXT: {{[^@]+}}call void @llvm.wasm.memory.storeztag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) +// CHECK-NEXT: ret void +// +void test_builtin_wasm_memory_storeztag(void *p, __SIZE_TYPE__ b16) { + __builtin_wasm_memory_storeztag(p, b16); +} + +// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_store1tag +// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: entry: +// CHECK-NEXT: {{[^@]+}}call void @llvm.wasm.memory.store1tag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) +// CHECK-NEXT: ret void +// +void test_builtin_wasm_memory_store1tag(void *p, __SIZE_TYPE__ b16) { + __builtin_wasm_memory_store1tag(p, b16); +} + +// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_storez1tag +// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: entry: +// CHECK-NEXT: {{[^@]+}}call void @llvm.wasm.memory.storez1tag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) +// CHECK-NEXT: ret void +// +void test_builtin_wasm_memory_storez1tag(void *p, __SIZE_TYPE__ b16) { + __builtin_wasm_memory_storez1tag(p, b16); +} From 9b7e83c0c2f79a4839ff6b7b78da33ff64ffa9e1 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 9 Dec 2023 22:04:06 -0500 Subject: [PATCH 046/111] Initial Attempt to implement stack tagging and untagging --- .../WebAssembly/WebAssemblyStackTagging.cpp | 84 +++++++++---------- 1 file changed, 39 insertions(+), 45 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index fb54b1f993761..0ba5daa84ceae 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -12,12 +12,14 @@ #include "llvm/IR/InstIterator.h" #include "llvm/IR/ValueHandle.h" #include "llvm/IR/IRBuilder.h" +#include "llvm/IR/IntrinsicInst.h" #include "llvm/Transforms/Utils/Local.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Analysis/AliasAnalysis.h" #include "llvm/Analysis/StackSafetyAnalysis.h" #include "llvm/Analysis/PostDominators.h" #include "llvm/Transforms/Utils/MemoryTaggingSupport.h" +#include "llvm/IR/IntrinsicsWebAssembly.h" using namespace llvm; @@ -31,12 +33,14 @@ struct WebAssemblyStackTagging : public FunctionPass { AAResults *AA = nullptr; WebAssemblyStackTagging() : FunctionPass(ID) {} - void tagAlloca(AllocaInst *AI, Instruction *InsertBefore, Value *Ptr, - uint64_t Size); - void untagAlloca(AllocaInst *AI, Instruction *InsertBefore, uint64_t Size); + void untagAlloca(AllocaInst *AI, Instruction *InsertBefore, + uint64_t Size, Function* StoreTagDecl, + Type* ArgOp0Type); bool runOnFunction(Function &) override; + private: + Function *F = nullptr; #if 1 void getAnalysisUsage(AnalysisUsage &AU) const override { AU.setPreservesCFG(); @@ -53,45 +57,20 @@ static const inline Align kTagGranuleSize = Align(16); } -void WebAssemblyStackTagging::tagAlloca(AllocaInst *AI, Instruction *InsertBefore, - Value *Ptr, uint64_t Size) { - -#if 0 - auto SetTagZeroFunc = - Intrinsic::getDeclaration(F->getParent(), Intrinsic::aarch64_settag_zero); - auto StgpFunc = - Intrinsic::getDeclaration(F->getParent(), Intrinsic::aarch64_stgp); - - InitializerBuilder IB(Size, DL, Ptr, SetTagFunc, SetTagZeroFunc, StgpFunc); - bool LittleEndian = - Triple(AI->getModule()->getTargetTriple()).isLittleEndian(); - // Current implementation of initializer merging assumes little endianness. - if (MergeInit && !F->hasOptNone() && LittleEndian && - Size < ClMergeInitSizeLimit) { - LLVM_DEBUG(dbgs() << "collecting initializers for " << *AI - << ", size = " << Size << "\n"); - InsertBefore = collectInitializers(InsertBefore, Ptr, Size, IB); - } - - IRBuilder<> IRB(InsertBefore); - IB.generate(IRB); -#endif -} - void WebAssemblyStackTagging::untagAlloca(AllocaInst *AI, Instruction *InsertBefore, - uint64_t Size) { -#if 0 + uint64_t Size, Function* StoreTagDecl, + Type* ArgOp0Type) { + IRBuilder<> IRB(InsertBefore); - IRB.CreateCall(SetTagFunc, {IRB.CreatePointerCast(AI, IRB.getPtrTy()), - ConstantInt::get(IRB.getInt64Ty(), Size)}); -#endif + IRB.CreateCall(StoreTagDecl, {AI, + ConstantInt::get(ArgOp0Type, Size)}); } bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { if (!Fn.hasFnAttribute(Attribute::SanitizeMemTag)) return false; - auto F = &Fn; + F = &Fn; SSI = &getAnalysis().getResult(); memtag::StackInfoBuilder SIB(SSI); for (Instruction &I : instructions(F)) @@ -127,43 +106,60 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { LI = DeleteLI.get(); } + Function *RandomTagDecl = + Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_randomtag); -#if 1 - int NextTag = 0; for (auto &I : SInfo.AllocasToInstrument) { memtag::AllocaInfo &Info = I.second; TrackingVH OldAI = Info.AI; memtag::alignAndPadAlloca(Info, kTagGranuleSize); AllocaInst *AI = Info.AI; - int Tag = NextTag; - NextTag = (NextTag + 1) % 16; IRBuilder<> IRB(Info.AI->getNextNode()); + Instruction *RandomTagCall = + IRB.CreateCall(RandomTagDecl, {Info.AI}); + + if (Info.AI->hasName()) + RandomTagCall->setName(Info.AI->getName() + ".tag"); + Info.AI->replaceAllUsesWith(RandomTagCall); + RandomTagCall->setOperand(0, Info.AI); + // Calls to functions that may return twice (e.g. setjmp) confuse the // postdominator analysis, and will leave us to keep memory tagged after // function return. Work around this by always untagging at every return // statement if return_twice functions are called. bool StandardLifetime = +#if 0 SInfo.UnrecognizedLifetimes.empty() && memtag::isStandardLifetime(Info.LifetimeStart, Info.LifetimeEnd, DT, LI, 3) && !SInfo.CallsReturnTwice; -#if 0 +#else + true; +#endif if (StandardLifetime) { IntrinsicInst *Start = Info.LifetimeStart[0]; uint64_t Size = cast(Start->getArgOperand(0))->getZExtValue(); Size = alignTo(Size, kTagGranuleSize); - tagAlloca(AI, Start->getNextNode(), Start->getArgOperand(1), Size); - - auto TagEnd = [&](Instruction *Node) { untagAlloca(AI, Node, Size); }; + Type *ArgOp0Type = Start->getArgOperand(0)->getType(); + Function *StoreTagDecl = + Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_storetag, + ArgOp0Type); + auto TagEnd = [&](Instruction *Node) { + untagAlloca(AI, Node, Size, StoreTagDecl, ArgOp0Type); + }; if (!DT || !PDT || !memtag::forAllReachableExits(*DT, *PDT, *LI, Start, Info.LifetimeEnd, SInfo.RetVec, TagEnd)) { for (auto *End : Info.LifetimeEnd) End->eraseFromParent(); } - } else { + } +#if 0 + else { + + // To do uint64_t Size = *Info.AI->getAllocationSize(*DL); Value *Ptr = IRB.CreatePointerCast(TagPCall, IRB.getPtrTy()); tagAlloca(AI, &*IRB.GetInsertPoint(), Ptr, Size); @@ -178,9 +174,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { II->eraseFromParent(); } #endif -// LLVM_DEBUG(dbgs() << I << "\n"); } -#endif return true; } From 231876df601df198e03127483870eefbf1cbfd5e Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 9 Dec 2023 22:25:56 -0500 Subject: [PATCH 047/111] Add wasm.memory.randomstoretag instruction sets --- .../clang/Basic/BuiltinsWebAssembly.def | 4 ++ clang/lib/CodeGen/CGBuiltin.cpp | 24 ++++++++ .../CodeGen/WebAssembly/builtins-memtag.c | 40 +++++++++++++ llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 12 ++++ .../WebAssembly/WebAssemblyInstrMemtag.td | 32 ++++++++++ .../test/CodeGen/WebAssembly/memory-memtag.ll | 60 +++++++++++++++++++ 6 files changed, 172 insertions(+) diff --git a/clang/include/clang/Basic/BuiltinsWebAssembly.def b/clang/include/clang/Basic/BuiltinsWebAssembly.def index 679e9b2e0dfc2..1790c156755cc 100644 --- a/clang/include/clang/Basic/BuiltinsWebAssembly.def +++ b/clang/include/clang/Basic/BuiltinsWebAssembly.def @@ -34,6 +34,10 @@ BUILTIN(__builtin_wasm_memory_storetag, "vv*z", "n") BUILTIN(__builtin_wasm_memory_storeztag, "vv*z", "n") BUILTIN(__builtin_wasm_memory_store1tag, "vv*z", "n") BUILTIN(__builtin_wasm_memory_storez1tag, "vv*z", "n") +BUILTIN(__builtin_wasm_memory_randomstoretag, "v*v*z", "n") +BUILTIN(__builtin_wasm_memory_randomstoreztag, "v*v*z", "n") +BUILTIN(__builtin_wasm_memory_randomstore1tag, "v*v*z", "n") +BUILTIN(__builtin_wasm_memory_randomstorez1tag, "v*v*z", "n") // Thread-local storage TARGET_BUILTIN(__builtin_wasm_tls_size, "z", "nc", "bulk-memory") diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 3c5feae59a96a..51ca4840021ed 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -20564,6 +20564,30 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storez1tag, B16->getType()); return Builder.CreateCall(Callee, {Ptr, B16}); } + case WebAssembly::BI__builtin_wasm_memory_randomstoretag: { + Value *Ptr = EmitScalarExpr(E->getArg(0)); + Value *B16 = EmitScalarExpr(E->getArg(1)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstoretag, B16->getType()); + return Builder.CreateCall(Callee, {Ptr, B16}); + } + case WebAssembly::BI__builtin_wasm_memory_randomstoreztag: { + Value *Ptr = EmitScalarExpr(E->getArg(0)); + Value *B16 = EmitScalarExpr(E->getArg(1)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstoreztag, B16->getType()); + return Builder.CreateCall(Callee, {Ptr, B16}); + } + case WebAssembly::BI__builtin_wasm_memory_randomstore1tag: { + Value *Ptr = EmitScalarExpr(E->getArg(0)); + Value *B16 = EmitScalarExpr(E->getArg(1)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstore1tag, B16->getType()); + return Builder.CreateCall(Callee, {Ptr, B16}); + } + case WebAssembly::BI__builtin_wasm_memory_randomstorez1tag: { + Value *Ptr = EmitScalarExpr(E->getArg(0)); + Value *B16 = EmitScalarExpr(E->getArg(1)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstorez1tag, B16->getType()); + return Builder.CreateCall(Callee, {Ptr, B16}); + } default: return nullptr; } diff --git a/clang/test/CodeGen/WebAssembly/builtins-memtag.c b/clang/test/CodeGen/WebAssembly/builtins-memtag.c index c6327b0a6b70b..ed52d94478e8d 100644 --- a/clang/test/CodeGen/WebAssembly/builtins-memtag.c +++ b/clang/test/CodeGen/WebAssembly/builtins-memtag.c @@ -81,3 +81,43 @@ void test_builtin_wasm_memory_store1tag(void *p, __SIZE_TYPE__ b16) { void test_builtin_wasm_memory_storez1tag(void *p, __SIZE_TYPE__ b16) { __builtin_wasm_memory_storez1tag(p, b16); } + +// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_randomstoretag +// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: entry: +// CHECK-NEXT: {{[^@]+}}call ptr @llvm.wasm.memory.randomstoretag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) +// CHECK-NEXT: ret ptr +// +void* test_builtin_wasm_memory_randomstoretag(void *p, __SIZE_TYPE__ b16) { + return __builtin_wasm_memory_randomstoretag(p, b16); +} + +// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_randomstoreztag +// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: entry: +// CHECK-NEXT: {{[^@]+}}call ptr @llvm.wasm.memory.randomstoreztag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) +// CHECK-NEXT: ret ptr +// +void* test_builtin_wasm_memory_randomstoreztag(void *p, __SIZE_TYPE__ b16) { + return __builtin_wasm_memory_randomstoreztag(p, b16); +} + +// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_randomstore1tag +// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: entry: +// CHECK-NEXT: {{[^@]+}}call ptr @llvm.wasm.memory.randomstore1tag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) +// CHECK-NEXT: ret ptr +// +void* test_builtin_wasm_memory_randomstore1tag(void *p, __SIZE_TYPE__ b16) { + return __builtin_wasm_memory_randomstore1tag(p, b16); +} + +// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_randomstorez1tag +// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: entry: +// CHECK-NEXT: {{[^@]+}}call ptr @llvm.wasm.memory.randomstorez1tag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) +// CHECK-NEXT: ret ptr +// +void* test_builtin_wasm_memory_randomstorez1tag(void *p, __SIZE_TYPE__ b16) { + return __builtin_wasm_memory_randomstorez1tag(p, b16); +} diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index 1e779d6b7349e..782271225b9bf 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -369,4 +369,16 @@ def int_wasm_memory_store1tag : def int_wasm_memory_storez1tag : DefaultAttrsIntrinsic<[], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storez1tag">; +def int_wasm_memory_randomstoretag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoretag">; + +def int_wasm_memory_randomstoreztag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoreztag">; + +def int_wasm_memory_randomstore1tag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstore1tag">; + +def int_wasm_memory_randomstorez1tag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstorez1tag">; + } // TargetPrefix = "wasm" diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 5cc3da65767b3..1458bd8e113d2 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -73,6 +73,38 @@ defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins rc:$src, rc:$b16), "memory.storez1tag\t", 0xfc27>; +defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins rc:$src, rc:$b16), + (outs), (ins), + [(set rc:$dst, + (int_wasm_memory_randomstoretag rc:$src, rc:$b16))], + "memory.randomstoretag\t$dst, $src, $b16", + "memory.randomstoretag\t", + 0xfc28>; + +defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins rc:$src, rc:$b16), + (outs), (ins), + [(set rc:$dst, + (int_wasm_memory_randomstoreztag rc:$src, rc:$b16))], + "memory.randomstoreztag\t$dst, $src, $b16", + "memory.randomstoreztag\t", + 0xfc29>; + +defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins rc:$src, rc:$b16), + (outs), (ins), + [(set rc:$dst, + (int_wasm_memory_randomstore1tag rc:$src, rc:$b16))], + "memory.randomstore1tag\t$dst, $src, $b16", + "memory.randomstore1tag\t", + 0xfc30>; + +defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins rc:$src, rc:$b16), + (outs), (ins), + [(set rc:$dst, + (int_wasm_memory_randomstorez1tag rc:$src, rc:$b16))], + "memory.randomstorez1tag\t$dst, $src, $b16", + "memory.randomstorez1tag\t", + 0xfc31>; + } defm : MemoryTaggingOps; diff --git a/llvm/test/CodeGen/WebAssembly/memory-memtag.ll b/llvm/test/CodeGen/WebAssembly/memory-memtag.ll index a0147fdecbc85..917f5ec4fefc6 100644 --- a/llvm/test/CodeGen/WebAssembly/memory-memtag.ll +++ b/llvm/test/CodeGen/WebAssembly/memory-memtag.ll @@ -113,3 +113,63 @@ define void @memory_storez1tag(ptr %p0, i64 %b16) { ; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn declare void @llvm.wasm.memory.storez1tag(ptr, i64) + +; CHECK-LABEL: memory_randomstoretag: +; CHECK-NEXT: .functype memory_randomstoretag (i64, i64) -> (i64) +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: local.get 1 +; CHECK-NEXT: memory.randomstoretag +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: end_function +define ptr @memory_randomstoretag(ptr %p0, i64 %b16) { + call ptr @llvm.wasm.memory.randomstoretag(ptr %p0, i64 %b16) + ret ptr +} + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn +declare ptr @llvm.wasm.memory.randomstoretag(ptr, i64) + +; CHECK-LABEL: memory_randomstoreztag: +; CHECK-NEXT: .functype memory_randomstoreztag (i64, i64) -> (i64) +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: local.get 1 +; CHECK-NEXT: memory.randomstoreztag +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: end_function +define ptr @memory_randomstoreztag(ptr %p0, i64 %b16) { + call ptr @llvm.wasm.memory.randomstoreztag(ptr %p0, i64 %b16) + ret ptr +} + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn +declare ptr @llvm.wasm.memory.randomstoreztag(ptr, i64) + +; CHECK-LABEL: memory_randomstore1tag: +; CHECK-NEXT: .functype memory_randomstore1tag (i64, i64) -> (i64) +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: local.get 1 +; CHECK-NEXT: memory.randomstore1tag +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: end_function +define ptr @memory_randomstore1tag(ptr %p0, i64 %b16) { + call ptr @llvm.wasm.memory.randomstore1tag(ptr %p0, i64 %b16) + ret ptr +} + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn +declare ptr @llvm.wasm.memory.randomstore1tag(ptr, i64) + +; CHECK-LABEL: memory_randomstorez1tag: +; CHECK-NEXT: .functype memory_randomstorez1tag (i64, i64) -> (i64) +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: local.get 1 +; CHECK-NEXT: memory.randomstorez1tag +; CHECK-NEXT: local.get 0 +; CHECK-NEXT: end_function +define ptr @memory_randomstorez1tag(ptr %p0, i64 %b16) { + call ptr @llvm.wasm.memory.randomstorez1tag(ptr %p0, i64 %b16) + ret ptr +} + +; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn +declare ptr @llvm.wasm.memory.randomstorez1tag(ptr, i64) From 185dd071d1f9675e863111b7e3e7e9e6e8f4046b Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 10 Dec 2023 17:29:43 -0500 Subject: [PATCH 048/111] webassemblystacktagging --- .../WebAssembly/WebAssemblyStackTagging.cpp | 38 ++++++++----------- 1 file changed, 15 insertions(+), 23 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 0ba5daa84ceae..c8774561fea43 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -106,46 +106,41 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { LI = DeleteLI.get(); } - Function *RandomTagDecl = - Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_randomtag); - for (auto &I : SInfo.AllocasToInstrument) { memtag::AllocaInfo &Info = I.second; TrackingVH OldAI = Info.AI; memtag::alignAndPadAlloca(Info, kTagGranuleSize); AllocaInst *AI = Info.AI; IRBuilder<> IRB(Info.AI->getNextNode()); - Instruction *RandomTagCall = - IRB.CreateCall(RandomTagDecl, {Info.AI}); + IntrinsicInst *Start = Info.LifetimeStart[0]; + Type *ArgOp0Type = Start->getArgOperand(0)->getType(); + Function *RandomStoreTagDecl = + Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_randomstoretag, {ArgOp0Type}); + Function *StoreTagDecl = + Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_storetag, {ArgOp0Type}); + Instruction *RandomStoreTagCall = + IRB.CreateCall(RandomStoreTagDecl, {Info.AI}); if (Info.AI->hasName()) - RandomTagCall->setName(Info.AI->getName() + ".tag"); - Info.AI->replaceAllUsesWith(RandomTagCall); - RandomTagCall->setOperand(0, Info.AI); + RandomStoreTagCall->setName(Info.AI->getName() + ".tag"); + Info.AI->replaceAllUsesWith(RandomStoreTagCall); + RandomStoreTagCall->setOperand(0, Info.AI); // Calls to functions that may return twice (e.g. setjmp) confuse the // postdominator analysis, and will leave us to keep memory tagged after // function return. Work around this by always untagging at every return // statement if return_twice functions are called. bool StandardLifetime = -#if 0 SInfo.UnrecognizedLifetimes.empty() && memtag::isStandardLifetime(Info.LifetimeStart, Info.LifetimeEnd, DT, LI, 3) && !SInfo.CallsReturnTwice; -#else - true; -#endif if (StandardLifetime) { IntrinsicInst *Start = Info.LifetimeStart[0]; uint64_t Size = cast(Start->getArgOperand(0))->getZExtValue(); Size = alignTo(Size, kTagGranuleSize); - Type *ArgOp0Type = Start->getArgOperand(0)->getType(); - Function *StoreTagDecl = - Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_storetag, - ArgOp0Type); auto TagEnd = [&](Instruction *Node) { untagAlloca(AI, Node, Size, StoreTagDecl, ArgOp0Type); }; @@ -156,15 +151,13 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { End->eraseFromParent(); } } -#if 0 else { - - // To do uint64_t Size = *Info.AI->getAllocationSize(*DL); - Value *Ptr = IRB.CreatePointerCast(TagPCall, IRB.getPtrTy()); - tagAlloca(AI, &*IRB.GetInsertPoint(), Ptr, Size); + IRBuilder<> IRB(&*IRB.GetInsertPoint()); + IRB.CreateCall(RandomStoreTagDecl, {AI, + ConstantInt::get(ArgOp0Type, Size)}); for (auto *RI : SInfo.RetVec) { - untagAlloca(AI, RI, Size); + untagAlloca(AI, Node, Size, StoreTagDecl, ArgOp0Type); } // We may have inserted tag/untag outside of any lifetime interval. // Remove all lifetime intrinsics for this alloca. @@ -173,7 +166,6 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { for (auto *II : Info.LifetimeEnd) II->eraseFromParent(); } -#endif } return true; } From 7b19ff762902245c8473d598dc34f07b684a4601 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 10 Dec 2023 17:37:00 -0500 Subject: [PATCH 049/111] fix typo error --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index c8774561fea43..afcacb9c8bfc0 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -30,6 +30,7 @@ namespace { struct WebAssemblyStackTagging : public FunctionPass { static char ID; StackSafetyGlobalInfo const *SSI = nullptr; + DataLayout const *DL = nullptr; AAResults *AA = nullptr; WebAssemblyStackTagging() : FunctionPass(ID) {} @@ -71,6 +72,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { return false; F = &Fn; + DL = &Fn.getParent()->getDataLayout(); SSI = &getAnalysis().getResult(); memtag::StackInfoBuilder SIB(SSI); for (Instruction &I : instructions(F)) @@ -157,7 +159,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { IRB.CreateCall(RandomStoreTagDecl, {AI, ConstantInt::get(ArgOp0Type, Size)}); for (auto *RI : SInfo.RetVec) { - untagAlloca(AI, Node, Size, StoreTagDecl, ArgOp0Type); + untagAlloca(AI, RI, Size, StoreTagDecl, ArgOp0Type); } // We may have inserted tag/untag outside of any lifetime interval. // Remove all lifetime intrinsics for this alloca. From 759ab085b1242289e37068f6855cc684c45db045 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 10 Dec 2023 19:24:29 -0500 Subject: [PATCH 050/111] fix some part of it --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index afcacb9c8bfc0..461ffdf2069c5 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -117,12 +117,15 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { IntrinsicInst *Start = Info.LifetimeStart[0]; Type *ArgOp0Type = Start->getArgOperand(0)->getType(); +// ::llvm::errs()<<"PR120\t"<<*ArgOp0Type<<'\n'; Function *RandomStoreTagDecl = Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_randomstoretag, {ArgOp0Type}); +// ::llvm::errs()<<"PR123\n"; Function *StoreTagDecl = - Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_storetag, {ArgOp0Type}); + Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_storetag); Instruction *RandomStoreTagCall = IRB.CreateCall(RandomStoreTagDecl, {Info.AI}); +// ::llvm::errs()<<"RandomStoreTagCall\n"; if (Info.AI->hasName()) RandomStoreTagCall->setName(Info.AI->getName() + ".tag"); @@ -139,7 +142,6 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { 3) && !SInfo.CallsReturnTwice; if (StandardLifetime) { - IntrinsicInst *Start = Info.LifetimeStart[0]; uint64_t Size = cast(Start->getArgOperand(0))->getZExtValue(); Size = alignTo(Size, kTagGranuleSize); From 6eccf63d5168697e3b87bc45025ab14919f870a4 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 10 Dec 2023 19:41:02 -0500 Subject: [PATCH 051/111] wasm stack tagging --- .../WebAssembly/WebAssemblyStackTagging.cpp | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 461ffdf2069c5..84bee1cbe1be8 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -117,15 +117,16 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { IntrinsicInst *Start = Info.LifetimeStart[0]; Type *ArgOp0Type = Start->getArgOperand(0)->getType(); -// ::llvm::errs()<<"PR120\t"<<*ArgOp0Type<<'\n'; Function *RandomStoreTagDecl = Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_randomstoretag, {ArgOp0Type}); -// ::llvm::errs()<<"PR123\n"; Function *StoreTagDecl = Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_storetag); Instruction *RandomStoreTagCall = - IRB.CreateCall(RandomStoreTagDecl, {Info.AI}); -// ::llvm::errs()<<"RandomStoreTagCall\n"; + uint64_t Size = + cast(Start->getArgOperand(0))->getZExtValue(); + + Size = alignTo(Size, kTagGranuleSize); + IRB.CreateCall(RandomStoreTagDecl, {Info.AI, ConstantInt::get(ArgOp0Type, Size)}); if (Info.AI->hasName()) RandomStoreTagCall->setName(Info.AI->getName() + ".tag"); @@ -142,9 +143,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { 3) && !SInfo.CallsReturnTwice; if (StandardLifetime) { - uint64_t Size = - cast(Start->getArgOperand(0))->getZExtValue(); - Size = alignTo(Size, kTagGranuleSize); + auto TagEnd = [&](Instruction *Node) { untagAlloca(AI, Node, Size, StoreTagDecl, ArgOp0Type); }; @@ -156,7 +155,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { } } else { - uint64_t Size = *Info.AI->getAllocationSize(*DL); + Size = *Info.AI->getAllocationSize(*DL); IRBuilder<> IRB(&*IRB.GetInsertPoint()); IRB.CreateCall(RandomStoreTagDecl, {AI, ConstantInt::get(ArgOp0Type, Size)}); From ec22d62d8cab67064c1018e21c2f056e42e37d95 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 10 Dec 2023 23:03:08 -0500 Subject: [PATCH 052/111] Fix Wasm stack tagging --- .../Target/WebAssembly/WebAssemblyStackTagging.cpp | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 84bee1cbe1be8..b7975511e9ce6 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -120,19 +120,17 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { Function *RandomStoreTagDecl = Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_randomstoretag, {ArgOp0Type}); Function *StoreTagDecl = - Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_storetag); - Instruction *RandomStoreTagCall = + Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_storetag, {ArgOp0Type}); uint64_t Size = cast(Start->getArgOperand(0))->getZExtValue(); - Size = alignTo(Size, kTagGranuleSize); - IRB.CreateCall(RandomStoreTagDecl, {Info.AI, ConstantInt::get(ArgOp0Type, Size)}); - + Instruction *RandomStoreTagCall = + IRB.CreateCall(RandomStoreTagDecl, {Info.AI, ConstantInt::get(ArgOp0Type, Size)}); if (Info.AI->hasName()) RandomStoreTagCall->setName(Info.AI->getName() + ".tag"); Info.AI->replaceAllUsesWith(RandomStoreTagCall); RandomStoreTagCall->setOperand(0, Info.AI); - + // Calls to functions that may return twice (e.g. setjmp) confuse the // postdominator analysis, and will leave us to keep memory tagged after // function return. Work around this by always untagging at every return @@ -143,7 +141,6 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { 3) && !SInfo.CallsReturnTwice; if (StandardLifetime) { - auto TagEnd = [&](Instruction *Node) { untagAlloca(AI, Node, Size, StoreTagDecl, ArgOp0Type); }; From 0d7fdc0a5e2d9809b51e58729ed52bae00910e51 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Mon, 11 Dec 2023 18:37:30 -0500 Subject: [PATCH 053/111] fix webassemblystacktagging for a simple variable case --- .../WebAssembly/WebAssemblyStackTagging.cpp | 37 +++++++++---------- 1 file changed, 18 insertions(+), 19 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index b7975511e9ce6..861dff2c8cdb3 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -114,22 +114,11 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { memtag::alignAndPadAlloca(Info, kTagGranuleSize); AllocaInst *AI = Info.AI; IRBuilder<> IRB(Info.AI->getNextNode()); - IntrinsicInst *Start = Info.LifetimeStart[0]; - Type *ArgOp0Type = Start->getArgOperand(0)->getType(); - + Type *Int64Type = IRB.getInt64Ty(); Function *RandomStoreTagDecl = - Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_randomstoretag, {ArgOp0Type}); + Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_randomstoretag, {Int64Type}); Function *StoreTagDecl = - Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_storetag, {ArgOp0Type}); - uint64_t Size = - cast(Start->getArgOperand(0))->getZExtValue(); - Size = alignTo(Size, kTagGranuleSize); - Instruction *RandomStoreTagCall = - IRB.CreateCall(RandomStoreTagDecl, {Info.AI, ConstantInt::get(ArgOp0Type, Size)}); - if (Info.AI->hasName()) - RandomStoreTagCall->setName(Info.AI->getName() + ".tag"); - Info.AI->replaceAllUsesWith(RandomStoreTagCall); - RandomStoreTagCall->setOperand(0, Info.AI); + Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_storetag, {Int64Type}); // Calls to functions that may return twice (e.g. setjmp) confuse the // postdominator analysis, and will leave us to keep memory tagged after @@ -141,8 +130,19 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { 3) && !SInfo.CallsReturnTwice; if (StandardLifetime) { + IntrinsicInst *Start = Info.LifetimeStart[0]; + uint64_t Size = + cast(Start->getArgOperand(0))->getZExtValue(); + Size = alignTo(Size, kTagGranuleSize); + Instruction *RandomStoreTagCall = + IRB.CreateCall(RandomStoreTagDecl, {Info.AI, ConstantInt::get(Int64Type, Size)}); + if (Info.AI->hasName()) + RandomStoreTagCall->setName(Info.AI->getName() + ".tag"); + Info.AI->replaceAllUsesWith(RandomStoreTagCall); + RandomStoreTagCall->setOperand(0, Info.AI); + auto TagEnd = [&](Instruction *Node) { - untagAlloca(AI, Node, Size, StoreTagDecl, ArgOp0Type); + untagAlloca(AI, Node, Size, StoreTagDecl, Int64Type); }; if (!DT || !PDT || !memtag::forAllReachableExits(*DT, *PDT, *LI, Start, Info.LifetimeEnd, @@ -152,12 +152,11 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { } } else { - Size = *Info.AI->getAllocationSize(*DL); - IRBuilder<> IRB(&*IRB.GetInsertPoint()); + uint64_t Size = *Info.AI->getAllocationSize(*DL); IRB.CreateCall(RandomStoreTagDecl, {AI, - ConstantInt::get(ArgOp0Type, Size)}); + ConstantInt::get(Int64Type, Size)}); for (auto *RI : SInfo.RetVec) { - untagAlloca(AI, RI, Size, StoreTagDecl, ArgOp0Type); + untagAlloca(AI, RI, Size, StoreTagDecl, Int64Type); } // We may have inserted tag/untag outside of any lifetime interval. // Remove all lifetime intrinsics for this alloca. From 152d6d3d136d1e92a1855502f1c0698e2e3dee32 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Mon, 1 Jan 2024 07:02:15 -0500 Subject: [PATCH 054/111] fix triple --- llvm/include/llvm/TargetParser/Triple.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/include/llvm/TargetParser/Triple.h b/llvm/include/llvm/TargetParser/Triple.h index 47904621c0967..52f2b5c3a7564 100644 --- a/llvm/include/llvm/TargetParser/Triple.h +++ b/llvm/include/llvm/TargetParser/Triple.h @@ -1012,7 +1012,7 @@ class Triple { /// Note: Android API level 29 (10) introduced ELF TLS. bool hasDefaultEmulatedTLS() const { return (isAndroid() && isAndroidVersionLT(29)) || isOSOpenBSD() || - isWindowsCygwinEnvironment() || isOHOSFamily(); + isOSCygMing() || isOHOSFamily(); } /// Tests whether the target uses -data-sections as default. From 33df851246dcd96e7fe3cb0560bfb55f72d7a5c3 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 6 Jan 2024 15:35:49 -0500 Subject: [PATCH 055/111] Fix WebAssembly Memory Tagging by ignoring stacksafetyanalysis --- .../WebAssembly/WebAssemblyStackTagging.cpp | 72 ++++++++++--------- 1 file changed, 38 insertions(+), 34 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 861dff2c8cdb3..8839d47b20c08 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -6,20 +6,20 @@ // //===----------------------------------------------------------------------===// #include "WebAssembly.h" -#include "llvm/InitializePasses.h" -#include "llvm/Pass.h" +#include "llvm/Analysis/AliasAnalysis.h" +#include "llvm/Analysis/PostDominators.h" +#include "llvm/Analysis/StackSafetyAnalysis.h" #include "llvm/IR/Function.h" -#include "llvm/IR/InstIterator.h" -#include "llvm/IR/ValueHandle.h" #include "llvm/IR/IRBuilder.h" +#include "llvm/IR/InstIterator.h" #include "llvm/IR/IntrinsicInst.h" -#include "llvm/Transforms/Utils/Local.h" +#include "llvm/IR/IntrinsicsWebAssembly.h" +#include "llvm/IR/ValueHandle.h" +#include "llvm/InitializePasses.h" +#include "llvm/Pass.h" #include "llvm/Support/raw_ostream.h" -#include "llvm/Analysis/AliasAnalysis.h" -#include "llvm/Analysis/StackSafetyAnalysis.h" -#include "llvm/Analysis/PostDominators.h" +#include "llvm/Transforms/Utils/Local.h" #include "llvm/Transforms/Utils/MemoryTaggingSupport.h" -#include "llvm/IR/IntrinsicsWebAssembly.h" using namespace llvm; @@ -34,9 +34,8 @@ struct WebAssemblyStackTagging : public FunctionPass { AAResults *AA = nullptr; WebAssemblyStackTagging() : FunctionPass(ID) {} - void untagAlloca(AllocaInst *AI, Instruction *InsertBefore, - uint64_t Size, Function* StoreTagDecl, - Type* ArgOp0Type); + void untagAlloca(AllocaInst *AI, Instruction *InsertBefore, uint64_t Size, + Function *StoreTagDecl, Type *ArgOp0Type); bool runOnFunction(Function &) override; @@ -56,27 +55,33 @@ struct WebAssemblyStackTagging : public FunctionPass { static const inline Align kTagGranuleSize = Align(16); -} +} // namespace -void WebAssemblyStackTagging::untagAlloca(AllocaInst *AI, Instruction *InsertBefore, - uint64_t Size, Function* StoreTagDecl, - Type* ArgOp0Type) { +void WebAssemblyStackTagging::untagAlloca(AllocaInst *AI, + Instruction *InsertBefore, + uint64_t Size, Function *StoreTagDecl, + Type *ArgOp0Type) { IRBuilder<> IRB(InsertBefore); - IRB.CreateCall(StoreTagDecl, {AI, - ConstantInt::get(ArgOp0Type, Size)}); + IRB.CreateCall(StoreTagDecl, {AI, ConstantInt::get(ArgOp0Type, Size)}); } -bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { +bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { if (!Fn.hasFnAttribute(Attribute::SanitizeMemTag)) return false; F = &Fn; DL = &Fn.getParent()->getDataLayout(); +#if 0 +// Unsure of the purpose of the SSI analysis in this context. +// Please place it under further review. SSI = &getAnalysis().getResult(); +#endif memtag::StackInfoBuilder SIB(SSI); - for (Instruction &I : instructions(F)) + for (Instruction &I : instructions(F)) { + ::llvm::errs() << I << '\n'; SIB.visit(I); + } memtag::StackInfo &SInfo = SIB.get(); std::unique_ptr DeleteDT; @@ -115,10 +120,10 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { AllocaInst *AI = Info.AI; IRBuilder<> IRB(Info.AI->getNextNode()); Type *Int64Type = IRB.getInt64Ty(); - Function *RandomStoreTagDecl = - Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_randomstoretag, {Int64Type}); - Function *StoreTagDecl = - Intrinsic::getDeclaration(F->getParent(), Intrinsic::wasm_memory_storetag, {Int64Type}); + Function *RandomStoreTagDecl = Intrinsic::getDeclaration( + F->getParent(), Intrinsic::wasm_memory_randomstoretag, {Int64Type}); + Function *StoreTagDecl = Intrinsic::getDeclaration( + F->getParent(), Intrinsic::wasm_memory_storetag, {Int64Type}); // Calls to functions that may return twice (e.g. setjmp) confuse the // postdominator analysis, and will leave us to keep memory tagged after @@ -134,8 +139,8 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { uint64_t Size = cast(Start->getArgOperand(0))->getZExtValue(); Size = alignTo(Size, kTagGranuleSize); - Instruction *RandomStoreTagCall = - IRB.CreateCall(RandomStoreTagDecl, {Info.AI, ConstantInt::get(Int64Type, Size)}); + Instruction *RandomStoreTagCall = IRB.CreateCall( + RandomStoreTagDecl, {Info.AI, ConstantInt::get(Int64Type, Size)}); if (Info.AI->hasName()) RandomStoreTagCall->setName(Info.AI->getName() + ".tag"); Info.AI->replaceAllUsesWith(RandomStoreTagCall); @@ -150,11 +155,10 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { for (auto *End : Info.LifetimeEnd) End->eraseFromParent(); } - } - else { + } else { uint64_t Size = *Info.AI->getAllocationSize(*DL); - IRB.CreateCall(RandomStoreTagDecl, {AI, - ConstantInt::get(Int64Type, Size)}); + IRB.CreateCall(RandomStoreTagDecl, + {AI, ConstantInt::get(Int64Type, Size)}); for (auto *RI : SInfo.RetVec) { untagAlloca(AI, RI, Size, StoreTagDecl, Int64Type); } @@ -170,14 +174,14 @@ bool WebAssemblyStackTagging::runOnFunction(Function & Fn) { } char WebAssemblyStackTagging::ID = 0; -INITIALIZE_PASS_BEGIN(WebAssemblyStackTagging, DEBUG_TYPE, "WebAssembly Stack Tagging", - false, false) +INITIALIZE_PASS_BEGIN(WebAssemblyStackTagging, DEBUG_TYPE, + "WebAssembly Stack Tagging", false, false) #if 0 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass) #endif INITIALIZE_PASS_DEPENDENCY(StackSafetyGlobalInfoWrapperPass) -INITIALIZE_PASS_END(WebAssemblyStackTagging, DEBUG_TYPE, "WebAssembly Stack Tagging", - false, false) +INITIALIZE_PASS_END(WebAssemblyStackTagging, DEBUG_TYPE, + "WebAssembly Stack Tagging", false, false) FunctionPass *llvm::createWebAssemblyStackTaggingPass() { return new WebAssemblyStackTagging(); From 549d476749181d7442f848a3a1a409637a87eec9 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 6 Jan 2024 15:41:15 -0500 Subject: [PATCH 056/111] remove debugging code --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 8839d47b20c08..1919c5409971f 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -78,10 +78,8 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { SSI = &getAnalysis().getResult(); #endif memtag::StackInfoBuilder SIB(SSI); - for (Instruction &I : instructions(F)) { - ::llvm::errs() << I << '\n'; + for (Instruction &I : instructions(F)) SIB.visit(I); - } memtag::StackInfo &SInfo = SIB.get(); std::unique_ptr DeleteDT; From ab95fa8297491f5c34efcd526d212e3bf5e931bd Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 6 Jan 2024 15:52:36 -0500 Subject: [PATCH 057/111] Enable stacksafetyanalysis --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 1919c5409971f..ae7cbad223cbc 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -72,7 +72,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { F = &Fn; DL = &Fn.getParent()->getDataLayout(); -#if 0 +#if 1 // Unsure of the purpose of the SSI analysis in this context. // Please place it under further review. SSI = &getAnalysis().getResult(); From daa29bf852fe2158df2f6403228ab260d2cfccba Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 6 Jan 2024 19:04:53 -0500 Subject: [PATCH 058/111] add a new wasm memtag instruction --- .../WebAssembly/WebAssemblyInstrMemtag.td | 132 ++++++++++-------- .../WebAssembly/WebAssemblyStackTagging.cpp | 11 +- 2 files changed, 76 insertions(+), 67 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 1458bd8e113d2..a3c8dc1f3d5f8 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -13,97 +13,105 @@ multiclass MemoryTaggingOps { -defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins rc:$src), - (outs), (ins), +defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, ins rc:$src), + (outs), (ins i32imm:$flags), [(set rc:$dst, - (int_wasm_memory_randomtag rc:$src))], - "memory.randomtag\t$dst, $src", - "memory.randomtag\t", + (int_wasm_memory_randomtag i32imm:$flags, rc:$src))], + "memory.randomtag\t$dst, $flags, $src", + "memory.randomtag\t$flags", 0xfc20>; -defm MEMORY_COPYTAG_A#B: I<(outs rc:$dstwsrctag), (ins rc:$dst, rc:$src), - (outs), (ins), +defm MEMORY_COPYTAG_A#B: I<(outs rc:$dstwsrctag), (ins i32imm:$flags, ins rc:$dst, rc:$src), + (outs), (ins i32imm:$flags), [(set rc:$dstwsrctag, - (int_wasm_memory_copytag rc:$dst, rc:$src))], - "memory.copytag\t$dstwsrctag, $dst, $src", - "memory.copytag\t", + (int_wasm_memory_copytag i32imm:$flags, rc:$dst, rc:$src))], + "memory.copytag\t$dstwsrctag, $flags, $dst, $src", + "memory.copytag\t$flags", 0xfc21>; -defm MEMORY_SUBTAG_A#B: I<(outs rc:$diff), (ins rc:$minuendptr, rc:$subtrahendptr), - (outs), (ins), +defm MEMORY_SUBTAG_A#B: I<(outs rc:$diff), (ins i32imm:$flags, ins rc:$minuendptr, rc:$subtrahendptr), + (outs), (ins i32imm:$flags), [(set rc:$diff, - (int_wasm_memory_subtag rc:$minuendptr, rc:$subtrahendptr))], - "memory.subtag\t$diff, $minuendptr, $subtrahendptr", - "memory.subtag\t", + (int_wasm_memory_subtag i32imm:$flags, rc:$minuendptr, rc:$subtrahendptr))], + "memory.subtag\t$diff, $flags, $minuendptr, $subtrahendptr", + "memory.subtag\t$flags", 0xfc22>; -defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins rc:$src), - (outs), (ins), +defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins i32imm:$flags, ins rc:$src), + (outs), (ins i32imm:$flags), [(set rc:$taggedptr, - (int_wasm_memory_loadtag rc:$src))], - "memory.loadtag\t$taggedptr, $src", - "memory.loadtag\t", + (int_wasm_memory_loadtag i32imm:$flags, rc:$src))], + "memory.loadtag\t$taggedptr, $flags, $src", + "memory.loadtag\t$flags", 0xfc23>; -defm MEMORY_STORETAG_A#B: I<(outs), (ins rc:$src, rc:$b16), - (outs), (ins), - [(int_wasm_memory_storetag rc:$src, rc:$b16)], - "memory.storetag\t$src, $b16", - "memory.storetag\t", +defm MEMORY_STORETAG_A#B: I<(outs), (ins i32imm:$flags, ins rc:$src, rc:$b16), + (outs), (ins i32imm:$flags), + [(int_wasm_memory_storetag i32imm:$flags, rc:$src, rc:$b16)], + "memory.storetag\t$flags, $src, $b16", + "memory.storetag\t$flags", 0xfc24>; -defm MEMORY_STOREZTAG_A#B: I<(outs), (ins rc:$src, rc:$b16), - (outs), (ins), - [(int_wasm_memory_storeztag rc:$src, rc:$b16)], - "memory.storeztag\t$src, $b16", - "memory.storeztag\t", +defm MEMORY_STOREZTAG_A#B: I<(outs), (ins i32imm:$flags, ins rc:$src, rc:$b16), + (outs), (ins i32imm:$flags), + [(int_wasm_memory_storeztag i32imm:$flags, rc:$src, rc:$b16)], + "memory.storeztag\t$flags, $src, $b16", + "memory.storeztag\t$flags", 0xfc25>; -defm MEMORY_STORE1TAG_A#B: I<(outs), (ins rc:$src, rc:$b16), - (outs), (ins), - [(int_wasm_memory_store1tag rc:$src, rc:$b16)], - "memory.store1tag\t$src, $b16", - "memory.store1tag\t", +defm MEMORY_STORE1TAG_A#B: I<(outs), (ins i32imm:$flags, ins rc:$src, rc:$b16), + (outs), (ins i32imm:$flags), + [(int_wasm_memory_store1tag i32imm:$flags, rc:$src, rc:$b16)], + "memory.store1tag\t$flags, $src, $b16", + "memory.store1tag\t$flags", 0xfc26>; -defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins rc:$src, rc:$b16), - (outs), (ins), - [(int_wasm_memory_storez1tag rc:$src, rc:$b16)], - "memory.storez1tag\t$src, $b16", - "memory.storez1tag\t", +defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins i32imm:$flags, ins rc:$src, rc:$b16), + (outs), (ins i32imm:$flags), + [(int_wasm_memory_storez1tag i32imm:$flags, rc:$src, rc:$b16)], + "memory.storez1tag\t$flags, $src, $b16", + "memory.storez1tag\t$flags", 0xfc27>; -defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins rc:$src, rc:$b16), - (outs), (ins), +defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, rc:$b16), + (outs), (ins i32imm:$flags), [(set rc:$dst, - (int_wasm_memory_randomstoretag rc:$src, rc:$b16))], - "memory.randomstoretag\t$dst, $src, $b16", - "memory.randomstoretag\t", + (int_wasm_memory_randomstoretag rc:$src, i32 imm:$flags, rc:$b16))], + "memory.randomstoretag\t$dst, $flags, $src, $b16", + "memory.randomstoretag\t$flags", 0xfc28>; -defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins rc:$src, rc:$b16), - (outs), (ins), +defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, rc:$b16), + (outs), (ins i32imm:$flags), [(set rc:$dst, - (int_wasm_memory_randomstoreztag rc:$src, rc:$b16))], - "memory.randomstoreztag\t$dst, $src, $b16", - "memory.randomstoreztag\t", + (int_wasm_memory_randomstoreztag rc:$src, i32 imm:$flags, rc:$b16))], + "memory.randomstoreztag\t$dst, $flags, $src, $b16", + "memory.randomstoreztag\t$flags", 0xfc29>; -defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins rc:$src, rc:$b16), - (outs), (ins), +defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, rc:$b16), + (outs), (ins i32imm:$flags), [(set rc:$dst, - (int_wasm_memory_randomstore1tag rc:$src, rc:$b16))], - "memory.randomstore1tag\t$dst, $src, $b16", - "memory.randomstore1tag\t", - 0xfc30>; + (int_wasm_memory_randomstore1tag rc:$src, i32 imm:$flags, rc:$b16))], + "memory.randomstore1tag\t$dst, $flags, $src, $b16", + "memory.randomstore1tag\t$flags", + 0xfc2a>; -defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins rc:$src, rc:$b16), - (outs), (ins), +defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, rc:$b16), + (outs), (ins i32imm:$flags), [(set rc:$dst, - (int_wasm_memory_randomstorez1tag rc:$src, rc:$b16))], - "memory.randomstorez1tag\t$dst, $src, $b16", - "memory.randomstorez1tag\t", - 0xfc31>; + (int_wasm_memory_randomstorez1tag rc:$src, i32 imm:$flags, rc:$b16))], + "memory.randomstorez1tag\t$dst, $flags, $src, $b16", + "memory.randomstorez1tag\t$flags", + 0xfc2b>; + +defm MEMORY_ADDNEXTTAG_A#B: I<(outs rc:$nexttaggedptr), (ins i32imm:$flags, ins rc:$taggedptr, ins rc:$offset), + (outs), (ins i32imm:$flags), + [(set rc:$nexttaggedptr, + (int_wasm_memory_addnexttag i32imm:$flags, rc:$taggedptr, rc:$offset))], + "memory.addnexttag\t$nexttaggedptr, $flags, $taggedptr, $offset", + "memory.addnexttag\t$flags", + 0xfc2c>; } diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index ae7cbad223cbc..abd8b769a7ae3 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -63,7 +63,7 @@ void WebAssemblyStackTagging::untagAlloca(AllocaInst *AI, Type *ArgOp0Type) { IRBuilder<> IRB(InsertBefore); - IRB.CreateCall(StoreTagDecl, {AI, ConstantInt::get(ArgOp0Type, Size)}); + IRB.CreateCall(StoreTagDecl, {AI, IRB.getInt32(0), ConstantInt::get(ArgOp0Type, Size)}); } bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { @@ -117,11 +117,12 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { memtag::alignAndPadAlloca(Info, kTagGranuleSize); AllocaInst *AI = Info.AI; IRBuilder<> IRB(Info.AI->getNextNode()); + Type *Int32Type = IRB.getInt32Ty(); Type *Int64Type = IRB.getInt64Ty(); Function *RandomStoreTagDecl = Intrinsic::getDeclaration( - F->getParent(), Intrinsic::wasm_memory_randomstoretag, {Int64Type}); + F->getParent(), Intrinsic::wasm_memory_randomstoretag, {Int32Type, Int64Type}); Function *StoreTagDecl = Intrinsic::getDeclaration( - F->getParent(), Intrinsic::wasm_memory_storetag, {Int64Type}); + F->getParent(), Intrinsic::wasm_memory_storetag, {Int32Type, Int64Type}); // Calls to functions that may return twice (e.g. setjmp) confuse the // postdominator analysis, and will leave us to keep memory tagged after @@ -138,7 +139,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { cast(Start->getArgOperand(0))->getZExtValue(); Size = alignTo(Size, kTagGranuleSize); Instruction *RandomStoreTagCall = IRB.CreateCall( - RandomStoreTagDecl, {Info.AI, ConstantInt::get(Int64Type, Size)}); + RandomStoreTagDecl, {Info.AI, ConstantInt::get(Int32Type, 0), ConstantInt::get(Int64Type, Size)}); if (Info.AI->hasName()) RandomStoreTagCall->setName(Info.AI->getName() + ".tag"); Info.AI->replaceAllUsesWith(RandomStoreTagCall); @@ -156,7 +157,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { } else { uint64_t Size = *Info.AI->getAllocationSize(*DL); IRB.CreateCall(RandomStoreTagDecl, - {AI, ConstantInt::get(Int64Type, Size)}); + {AI, ConstantInt::get(Int32Type, 0), ConstantInt::get(Int64Type, Size)}); for (auto *RI : SInfo.RetVec) { untagAlloca(AI, RI, Size, StoreTagDecl, Int64Type); } From 7d5a87eabc4414bf1c662b62934b4f7eee702724 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 6 Jan 2024 19:07:18 -0500 Subject: [PATCH 059/111] remove redundant ins in wasmtag to support multi memory --- .../WebAssembly/WebAssemblyInstrMemtag.td | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index a3c8dc1f3d5f8..6094c4f7e90c7 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -13,7 +13,7 @@ multiclass MemoryTaggingOps { -defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, ins rc:$src), +defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src), (outs), (ins i32imm:$flags), [(set rc:$dst, (int_wasm_memory_randomtag i32imm:$flags, rc:$src))], @@ -21,7 +21,7 @@ defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, ins rc:$src), "memory.randomtag\t$flags", 0xfc20>; -defm MEMORY_COPYTAG_A#B: I<(outs rc:$dstwsrctag), (ins i32imm:$flags, ins rc:$dst, rc:$src), +defm MEMORY_COPYTAG_A#B: I<(outs rc:$dstwsrctag), (ins i32imm:$flags, rc:$dst, rc:$src), (outs), (ins i32imm:$flags), [(set rc:$dstwsrctag, (int_wasm_memory_copytag i32imm:$flags, rc:$dst, rc:$src))], @@ -29,7 +29,7 @@ defm MEMORY_COPYTAG_A#B: I<(outs rc:$dstwsrctag), (ins i32imm:$flags, ins rc:$ds "memory.copytag\t$flags", 0xfc21>; -defm MEMORY_SUBTAG_A#B: I<(outs rc:$diff), (ins i32imm:$flags, ins rc:$minuendptr, rc:$subtrahendptr), +defm MEMORY_SUBTAG_A#B: I<(outs rc:$diff), (ins i32imm:$flags, rc:$minuendptr, rc:$subtrahendptr), (outs), (ins i32imm:$flags), [(set rc:$diff, (int_wasm_memory_subtag i32imm:$flags, rc:$minuendptr, rc:$subtrahendptr))], @@ -37,7 +37,7 @@ defm MEMORY_SUBTAG_A#B: I<(outs rc:$diff), (ins i32imm:$flags, ins rc:$minuendpt "memory.subtag\t$flags", 0xfc22>; -defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins i32imm:$flags, ins rc:$src), +defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins i32imm:$flags, rc:$src), (outs), (ins i32imm:$flags), [(set rc:$taggedptr, (int_wasm_memory_loadtag i32imm:$flags, rc:$src))], @@ -45,28 +45,28 @@ defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins i32imm:$flags, ins rc:$src "memory.loadtag\t$flags", 0xfc23>; -defm MEMORY_STORETAG_A#B: I<(outs), (ins i32imm:$flags, ins rc:$src, rc:$b16), +defm MEMORY_STORETAG_A#B: I<(outs), (ins i32imm:$flags, rc:$src, rc:$b16), (outs), (ins i32imm:$flags), [(int_wasm_memory_storetag i32imm:$flags, rc:$src, rc:$b16)], "memory.storetag\t$flags, $src, $b16", "memory.storetag\t$flags", 0xfc24>; -defm MEMORY_STOREZTAG_A#B: I<(outs), (ins i32imm:$flags, ins rc:$src, rc:$b16), +defm MEMORY_STOREZTAG_A#B: I<(outs), (ins i32imm:$flags, rc:$src, rc:$b16), (outs), (ins i32imm:$flags), [(int_wasm_memory_storeztag i32imm:$flags, rc:$src, rc:$b16)], "memory.storeztag\t$flags, $src, $b16", "memory.storeztag\t$flags", 0xfc25>; -defm MEMORY_STORE1TAG_A#B: I<(outs), (ins i32imm:$flags, ins rc:$src, rc:$b16), +defm MEMORY_STORE1TAG_A#B: I<(outs), (ins i32imm:$flags, rc:$src, rc:$b16), (outs), (ins i32imm:$flags), [(int_wasm_memory_store1tag i32imm:$flags, rc:$src, rc:$b16)], "memory.store1tag\t$flags, $src, $b16", "memory.store1tag\t$flags", 0xfc26>; -defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins i32imm:$flags, ins rc:$src, rc:$b16), +defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins i32imm:$flags, rc:$src, rc:$b16), (outs), (ins i32imm:$flags), [(int_wasm_memory_storez1tag i32imm:$flags, rc:$src, rc:$b16)], "memory.storez1tag\t$flags, $src, $b16", @@ -105,7 +105,7 @@ defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, "memory.randomstorez1tag\t$flags", 0xfc2b>; -defm MEMORY_ADDNEXTTAG_A#B: I<(outs rc:$nexttaggedptr), (ins i32imm:$flags, ins rc:$taggedptr, ins rc:$offset), +defm MEMORY_ADDNEXTTAG_A#B: I<(outs rc:$nexttaggedptr), (ins i32imm:$flags, rc:$taggedptr, ins rc:$offset), (outs), (ins i32imm:$flags), [(set rc:$nexttaggedptr, (int_wasm_memory_addnexttag i32imm:$flags, rc:$taggedptr, rc:$offset))], From 98a036416381585ea83610ab26145a7992f8308f Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 6 Jan 2024 19:08:40 -0500 Subject: [PATCH 060/111] fix imm in wasm memtag --- llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 6094c4f7e90c7..a2d3e7cd265e7 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -76,7 +76,7 @@ defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins i32imm:$flags, rc:$src, rc:$b16), defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, rc:$b16), (outs), (ins i32imm:$flags), [(set rc:$dst, - (int_wasm_memory_randomstoretag rc:$src, i32 imm:$flags, rc:$b16))], + (int_wasm_memory_randomstoretag rc:$src, i32imm:$flags, rc:$b16))], "memory.randomstoretag\t$dst, $flags, $src, $b16", "memory.randomstoretag\t$flags", 0xfc28>; @@ -84,7 +84,7 @@ defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, r defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, rc:$b16), (outs), (ins i32imm:$flags), [(set rc:$dst, - (int_wasm_memory_randomstoreztag rc:$src, i32 imm:$flags, rc:$b16))], + (int_wasm_memory_randomstoreztag rc:$src, i32imm:$flags, rc:$b16))], "memory.randomstoreztag\t$dst, $flags, $src, $b16", "memory.randomstoreztag\t$flags", 0xfc29>; @@ -92,7 +92,7 @@ defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, rc:$b16), (outs), (ins i32imm:$flags), [(set rc:$dst, - (int_wasm_memory_randomstore1tag rc:$src, i32 imm:$flags, rc:$b16))], + (int_wasm_memory_randomstore1tag rc:$src, i32imm:$flags, rc:$b16))], "memory.randomstore1tag\t$dst, $flags, $src, $b16", "memory.randomstore1tag\t$flags", 0xfc2a>; @@ -100,7 +100,7 @@ defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, rc:$b16), (outs), (ins i32imm:$flags), [(set rc:$dst, - (int_wasm_memory_randomstorez1tag rc:$src, i32 imm:$flags, rc:$b16))], + (int_wasm_memory_randomstorez1tag rc:$src, i32imm:$flags, rc:$b16))], "memory.randomstorez1tag\t$dst, $flags, $src, $b16", "memory.randomstorez1tag\t$flags", 0xfc2b>; From 5a103491d98a8f931e69524e5f05984fec678b8a Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 6 Jan 2024 19:12:11 -0500 Subject: [PATCH 061/111] fix imm in wasm memtag --- llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index a2d3e7cd265e7..222d079913715 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -105,7 +105,7 @@ defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, "memory.randomstorez1tag\t$flags", 0xfc2b>; -defm MEMORY_ADDNEXTTAG_A#B: I<(outs rc:$nexttaggedptr), (ins i32imm:$flags, rc:$taggedptr, ins rc:$offset), +defm MEMORY_ADDNEXTTAG_A#B: I<(outs rc:$nexttaggedptr), (ins i32imm:$flags, rc:$taggedptr, rc:$offset), (outs), (ins i32imm:$flags), [(set rc:$nexttaggedptr, (int_wasm_memory_addnexttag i32imm:$flags, rc:$taggedptr, rc:$offset))], From b5a94debbe35c21b669bb0e4c12bcd9c32baa5a9 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 6 Jan 2024 19:40:42 -0500 Subject: [PATCH 062/111] Add builtin for __builtin_wasm_memory_addnexttag Change builtins to support multi memory --- .../clang/Basic/BuiltinsWebAssembly.def | 25 +++--- clang/lib/CodeGen/CGBuiltin.cpp | 87 +++++++++++-------- llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 27 +++--- 3 files changed, 81 insertions(+), 58 deletions(-) diff --git a/clang/include/clang/Basic/BuiltinsWebAssembly.def b/clang/include/clang/Basic/BuiltinsWebAssembly.def index 1790c156755cc..4172ba87c1323 100644 --- a/clang/include/clang/Basic/BuiltinsWebAssembly.def +++ b/clang/include/clang/Basic/BuiltinsWebAssembly.def @@ -26,18 +26,19 @@ BUILTIN(__builtin_wasm_memory_size, "zIi", "n") BUILTIN(__builtin_wasm_memory_grow, "zIiz", "n") // Memory Tagging -BUILTIN(__builtin_wasm_memory_randomtag, "v*v*", "n") -BUILTIN(__builtin_wasm_memory_copytag, "v*v*v*", "n") -BUILTIN(__builtin_wasm_memory_subtag, "Yv*v*", "n") -BUILTIN(__builtin_wasm_memory_loadtag, "v*v*", "n") -BUILTIN(__builtin_wasm_memory_storetag, "vv*z", "n") -BUILTIN(__builtin_wasm_memory_storeztag, "vv*z", "n") -BUILTIN(__builtin_wasm_memory_store1tag, "vv*z", "n") -BUILTIN(__builtin_wasm_memory_storez1tag, "vv*z", "n") -BUILTIN(__builtin_wasm_memory_randomstoretag, "v*v*z", "n") -BUILTIN(__builtin_wasm_memory_randomstoreztag, "v*v*z", "n") -BUILTIN(__builtin_wasm_memory_randomstore1tag, "v*v*z", "n") -BUILTIN(__builtin_wasm_memory_randomstorez1tag, "v*v*z", "n") +BUILTIN(__builtin_wasm_memory_randomtag, "v*Iiv*", "n") +BUILTIN(__builtin_wasm_memory_copytag, "v*Iiv*v*", "n") +BUILTIN(__builtin_wasm_memory_subtag, "YIiv*v*", "n") +BUILTIN(__builtin_wasm_memory_loadtag, "v*Iiv*", "n") +BUILTIN(__builtin_wasm_memory_storetag, "vIiv*z", "n") +BUILTIN(__builtin_wasm_memory_storeztag, "vIiv*z", "n") +BUILTIN(__builtin_wasm_memory_store1tag, "vIiv*z", "n") +BUILTIN(__builtin_wasm_memory_storez1tag, "vIiv*z", "n") +BUILTIN(__builtin_wasm_memory_randomstoretag, "vIi*v*z", "n") +BUILTIN(__builtin_wasm_memory_randomstoreztag, "vIi*v*z", "n") +BUILTIN(__builtin_wasm_memory_randomstore1tag, "vIi*v*z", "n") +BUILTIN(__builtin_wasm_memory_randomstorez1tag, "vIi*v*z", "n") +BUILTIN(__builtin_wasm_memory_addnexttag, "YIiv*z", "n") // Thread-local storage TARGET_BUILTIN(__builtin_wasm_tls_size, "z", "nc", "bulk-memory") diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index a8acf086273d7..2e45dac5c7cdc 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -20412,73 +20412,92 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, } case WebAssembly::BI__builtin_wasm_memory_randomtag: { Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomtag); - Value *Ptr = EmitScalarExpr(E->getArg(0)); - return Builder.CreateCall(Callee, {Ptr}); + Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + return Builder.CreateCall(Callee, {Table, Ptr}); } case WebAssembly::BI__builtin_wasm_memory_copytag: { Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_copytag); - Value *Ptr0 = EmitScalarExpr(E->getArg(0)); - Value *Ptr1 = EmitScalarExpr(E->getArg(1)); - return Builder.CreateCall(Callee, {Ptr0, Ptr1}); + Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Ptr0 = EmitScalarExpr(E->getArg(1)); + Value *Ptr1 = EmitScalarExpr(E->getArg(2)); + return Builder.CreateCall(Callee, {Table, Ptr0, Ptr1}); } case WebAssembly::BI__builtin_wasm_memory_subtag: { Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_subtag, ConvertType(E->getType())); - Value *Ptr0 = EmitScalarExpr(E->getArg(0)); - Value *Ptr1 = EmitScalarExpr(E->getArg(1)); - return Builder.CreateCall(Callee, {Ptr0, Ptr1}); + Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Ptr0 = EmitScalarExpr(E->getArg(1)); + Value *Ptr1 = EmitScalarExpr(E->getArg(2)); + return Builder.CreateCall(Callee, {Table, Ptr0, Ptr1}); } case WebAssembly::BI__builtin_wasm_memory_loadtag: { Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_loadtag); - Value *Ptr = EmitScalarExpr(E->getArg(0)); - return Builder.CreateCall(Callee, {Ptr}); + Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + return Builder.CreateCall(Callee, {Table, Ptr}); } case WebAssembly::BI__builtin_wasm_memory_storetag: { - Value *Ptr = EmitScalarExpr(E->getArg(0)); - Value *B16 = EmitScalarExpr(E->getArg(1)); + Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storetag, B16->getType()); - return Builder.CreateCall(Callee, {Ptr, B16}); + return Builder.CreateCall(Callee, {Table, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_storeztag: { - Value *Ptr = EmitScalarExpr(E->getArg(0)); - Value *B16 = EmitScalarExpr(E->getArg(1)); + Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storeztag, B16->getType()); - return Builder.CreateCall(Callee, {Ptr, B16}); + return Builder.CreateCall(Callee, {Table, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_store1tag: { - Value *Ptr = EmitScalarExpr(E->getArg(0)); - Value *B16 = EmitScalarExpr(E->getArg(1)); + Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_store1tag, B16->getType()); - return Builder.CreateCall(Callee, {Ptr, B16}); + return Builder.CreateCall(Callee, {Table, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_storez1tag: { - Value *Ptr = EmitScalarExpr(E->getArg(0)); - Value *B16 = EmitScalarExpr(E->getArg(1)); + Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storez1tag, B16->getType()); - return Builder.CreateCall(Callee, {Ptr, B16}); + return Builder.CreateCall(Callee, {Table, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_randomstoretag: { - Value *Ptr = EmitScalarExpr(E->getArg(0)); - Value *B16 = EmitScalarExpr(E->getArg(1)); + Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstoretag, B16->getType()); - return Builder.CreateCall(Callee, {Ptr, B16}); + return Builder.CreateCall(Callee, {Table, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_randomstoreztag: { - Value *Ptr = EmitScalarExpr(E->getArg(0)); - Value *B16 = EmitScalarExpr(E->getArg(1)); + Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstoreztag, B16->getType()); - return Builder.CreateCall(Callee, {Ptr, B16}); + return Builder.CreateCall(Callee, {Table, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_randomstore1tag: { - Value *Ptr = EmitScalarExpr(E->getArg(0)); - Value *B16 = EmitScalarExpr(E->getArg(1)); + Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstore1tag, B16->getType()); - return Builder.CreateCall(Callee, {Ptr, B16}); + return Builder.CreateCall(Callee, {Table, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_randomstorez1tag: { - Value *Ptr = EmitScalarExpr(E->getArg(0)); - Value *B16 = EmitScalarExpr(E->getArg(1)); + Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstorez1tag, B16->getType()); - return Builder.CreateCall(Callee, {Ptr, B16}); + return Builder.CreateCall(Callee, {Table, Ptr, B16}); + } + case WebAssembly::BI__builtin_wasm_memory_addnexttag: { + Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *PtrOffset = EmitScalarExpr(E->getArg(2)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_addnexttag, PtrOffset->getType()); + return Builder.CreateCall(Callee, {Table, Ptr, PtrOffset}); } default: return nullptr; diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index 782271225b9bf..b188abf3008c8 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -346,39 +346,42 @@ def int_wasm_tls_base : //===----------------------------------------------------------------------===// def int_wasm_memory_randomtag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.randomtag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.randomtag">; def int_wasm_memory_copytag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.copytag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.copytag">; def int_wasm_memory_subtag : - DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.subtag">; + DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.subtag">; def int_wasm_memory_loadtag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty], [IntrReadMem], "llvm.wasm.memory.loadtag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrReadMem], "llvm.wasm.memory.loadtag">; def int_wasm_memory_storetag : - DefaultAttrsIntrinsic<[], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storetag">; + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storetag">; def int_wasm_memory_storeztag : - DefaultAttrsIntrinsic<[], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storeztag">; + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storeztag">; def int_wasm_memory_store1tag : - DefaultAttrsIntrinsic<[], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.store1tag">; + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.store1tag">; def int_wasm_memory_storez1tag : - DefaultAttrsIntrinsic<[], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storez1tag">; + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storez1tag">; def int_wasm_memory_randomstoretag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoretag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoretag">; def int_wasm_memory_randomstoreztag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoreztag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoreztag">; def int_wasm_memory_randomstore1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstore1tag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstore1tag">; def int_wasm_memory_randomstorez1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstorez1tag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstorez1tag">; + +def int_wasm_memory_addnexttag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memory.addnexttag">; } // TargetPrefix = "wasm" From b0d7942412ad0e5abf815e526ab2213d610f82da Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 6 Jan 2024 20:01:05 -0500 Subject: [PATCH 063/111] fix compiler-rt for wasm64 --- compiler-rt/lib/builtins/fp_compare_impl.inc | 3 +++ 1 file changed, 3 insertions(+) diff --git a/compiler-rt/lib/builtins/fp_compare_impl.inc b/compiler-rt/lib/builtins/fp_compare_impl.inc index a9a4f6fbf5dfe..89cd83aa9f0be 100644 --- a/compiler-rt/lib/builtins/fp_compare_impl.inc +++ b/compiler-rt/lib/builtins/fp_compare_impl.inc @@ -21,6 +21,9 @@ typedef long long CMP_RESULT; #elif __AVR__ // AVR uses a single byte for the return value. typedef char CMP_RESULT; +#elif defined(__wasm64__) +// GCC uses int as CMP_RESULT +typedef int CMP_RESULT; #else // Otherwise the comparison functions return long. typedef long CMP_RESULT; From a1156a564c798192cb7608e28ce9b9ed846a8b1c Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 6 Jan 2024 20:21:06 -0500 Subject: [PATCH 064/111] Fix Multiple Build Errors on different platforms Particularly for canadian compilation --- .../pseudo/include/CMakeLists.txt | 12 +- clang/lib/Tooling/CMakeLists.txt | 10 +- compiler-rt/lib/builtins/fp_compare_impl.inc | 3 + lldb/source/Host/android/HostInfoAndroid.cpp | 4 + lldb/source/Host/android/LibcGlue.cpp | 2 + llvm/include/llvm/TargetParser/Triple.h | 287 +++++++----------- llvm/lib/Support/Unix/Unix.h | 17 +- mlir/lib/ExecutionEngine/CRunnerUtils.cpp | 4 +- 8 files changed, 147 insertions(+), 192 deletions(-) diff --git a/clang-tools-extra/pseudo/include/CMakeLists.txt b/clang-tools-extra/pseudo/include/CMakeLists.txt index 2334cfa12e337..605f17dd4591a 100644 --- a/clang-tools-extra/pseudo/include/CMakeLists.txt +++ b/clang-tools-extra/pseudo/include/CMakeLists.txt @@ -3,10 +3,18 @@ set(cxx_bnf ${CMAKE_CURRENT_SOURCE_DIR}/../lib/cxx/cxx.bnf) setup_host_tool(clang-pseudo-gen CLANG_PSEUDO_GEN pseudo_gen pseudo_gen_target) +if(NOT DEFINED CLANG_PSEUDO_GEN) + if(DEFINED LLVM_NATIVE_TOOL_DIR AND NOT LLVM_NATIVE_TOOL_DIR STREQUAL "") + set(CLANG_PSEUDO_GEN "${LLVM_NATIVE_TOOL_DIR}/clang_pseudo_gen") + else() + set(CLANG_PSEUDO_GEN "${pseudo_gen}") + endif() +endif() + # Generate inc files. set(cxx_symbols_inc ${CMAKE_CURRENT_BINARY_DIR}/CXXSymbols.inc) add_custom_command(OUTPUT ${cxx_symbols_inc} - COMMAND "${pseudo_gen}" + COMMAND "${CLANG_PSEUDO_GEN}" --grammar ${cxx_bnf} --emit-symbol-list -o ${cxx_symbols_inc} @@ -16,7 +24,7 @@ add_custom_command(OUTPUT ${cxx_symbols_inc} set(cxx_bnf_inc ${CMAKE_CURRENT_BINARY_DIR}/CXXBNF.inc) add_custom_command(OUTPUT ${cxx_bnf_inc} - COMMAND "${pseudo_gen}" + COMMAND "${CLANG_PSEUDO_GEN}" --grammar ${cxx_bnf} --emit-grammar-content -o ${cxx_bnf_inc} diff --git a/clang/lib/Tooling/CMakeLists.txt b/clang/lib/Tooling/CMakeLists.txt index aff39e4de13c0..1510f5fb8a081 100644 --- a/clang/lib/Tooling/CMakeLists.txt +++ b/clang/lib/Tooling/CMakeLists.txt @@ -53,6 +53,14 @@ else() list(APPEND implicitDirs -I ${implicitDir}) endforeach() + if(NOT DEFINED CLANG_AST_DUMP) + if(DEFINED LLVM_NATIVE_TOOL_DIR AND NOT LLVM_NATIVE_TOOL_DIR STREQUAL "") + set(CLANG_AST_DUMP ${LLVM_NATIVE_TOOL_DIR}/clang-ast-dump) + else() + set(CLANG_AST_DUMP $) + endif() + endif() + include(GetClangResourceDir) get_clang_resource_dir(resource_dir PREFIX ${LLVM_BINARY_DIR}) add_custom_command( @@ -60,7 +68,7 @@ else() OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/ASTNodeAPI.json DEPENDS clang-ast-dump clang-resource-headers COMMAND - $ + ${CLANG_AST_DUMP} # Skip this in debug mode because parsing AST.h is too slow --skip-processing=${skip_expensive_processing} -I ${resource_dir}/include diff --git a/compiler-rt/lib/builtins/fp_compare_impl.inc b/compiler-rt/lib/builtins/fp_compare_impl.inc index a9a4f6fbf5dfe..b2ebd0737df03 100644 --- a/compiler-rt/lib/builtins/fp_compare_impl.inc +++ b/compiler-rt/lib/builtins/fp_compare_impl.inc @@ -18,6 +18,9 @@ typedef int CMP_RESULT; #elif __SIZEOF_POINTER__ == 8 && __SIZEOF_LONG__ == 4 // LLP64 ABIs use long long instead of long. typedef long long CMP_RESULT; +#elif defined(__wasm64__) +// GCC uses int as CMP_RESULT +typedef int CMP_RESULT; #elif __AVR__ // AVR uses a single byte for the return value. typedef char CMP_RESULT; diff --git a/lldb/source/Host/android/HostInfoAndroid.cpp b/lldb/source/Host/android/HostInfoAndroid.cpp index 68440e016afe4..5ba2f0e24a8d2 100644 --- a/lldb/source/Host/android/HostInfoAndroid.cpp +++ b/lldb/source/Host/android/HostInfoAndroid.cpp @@ -6,6 +6,8 @@ // //===----------------------------------------------------------------------===// +#ifdef __ANDROID__ + #include "lldb/Host/android/HostInfoAndroid.h" #include "lldb/Host/FileSystem.h" #include "lldb/Host/linux/HostInfoLinux.h" @@ -92,3 +94,5 @@ bool HostInfoAndroid::ComputeTempFileBaseDirectory(FileSpec &file_spec) { return FileSystem::Instance().Exists(file_spec); } + +#endif diff --git a/lldb/source/Host/android/LibcGlue.cpp b/lldb/source/Host/android/LibcGlue.cpp index 877d735823fee..82b257719c2c8 100644 --- a/lldb/source/Host/android/LibcGlue.cpp +++ b/lldb/source/Host/android/LibcGlue.cpp @@ -8,6 +8,7 @@ // This files adds functions missing from libc on earlier versions of Android +#ifdef __ANDROID__ #include #include @@ -26,3 +27,4 @@ time_t timegm(struct tm *t) { return (time_t)timegm64(t); } int posix_openpt(int flags) { return open("/dev/ptmx", flags); } #endif +#endif diff --git a/llvm/include/llvm/TargetParser/Triple.h b/llvm/include/llvm/TargetParser/Triple.h index 47904621c0967..e022ad68c9651 100644 --- a/llvm/include/llvm/TargetParser/Triple.h +++ b/llvm/include/llvm/TargetParser/Triple.h @@ -46,64 +46,64 @@ class Triple { enum ArchType { UnknownArch, - arm, // ARM (little endian): arm, armv.*, xscale - armeb, // ARM (big endian): armeb - aarch64, // AArch64 (little endian): aarch64 - aarch64_be, // AArch64 (big endian): aarch64_be - aarch64_32, // AArch64 (little endian) ILP32: aarch64_32 - arc, // ARC: Synopsys ARC - avr, // AVR: Atmel AVR microcontroller - bpfel, // eBPF or extended BPF or 64-bit BPF (little endian) - bpfeb, // eBPF or extended BPF or 64-bit BPF (big endian) - csky, // CSKY: csky - dxil, // DXIL 32-bit DirectX bytecode - hexagon, // Hexagon: hexagon - loongarch32, // LoongArch (32-bit): loongarch32 - loongarch64, // LoongArch (64-bit): loongarch64 - m68k, // M68k: Motorola 680x0 family - mips, // MIPS: mips, mipsallegrex, mipsr6 - mipsel, // MIPSEL: mipsel, mipsallegrexe, mipsr6el - mips64, // MIPS64: mips64, mips64r6, mipsn32, mipsn32r6 - mips64el, // MIPS64EL: mips64el, mips64r6el, mipsn32el, mipsn32r6el - msp430, // MSP430: msp430 - ppc, // PPC: powerpc - ppcle, // PPCLE: powerpc (little endian) - ppc64, // PPC64: powerpc64, ppu - ppc64le, // PPC64LE: powerpc64le - r600, // R600: AMD GPUs HD2XXX - HD6XXX - amdgcn, // AMDGCN: AMD GCN GPUs - riscv32, // RISC-V (32-bit): riscv32 - riscv64, // RISC-V (64-bit): riscv64 - sparc, // Sparc: sparc - sparcv9, // Sparcv9: Sparcv9 - sparcel, // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant - systemz, // SystemZ: s390x - tce, // TCE (http://tce.cs.tut.fi/): tce - tcele, // TCE little endian (http://tce.cs.tut.fi/): tcele - thumb, // Thumb (little endian): thumb, thumbv.* - thumbeb, // Thumb (big endian): thumbeb - x86, // X86: i[3-9]86 - x86_64, // X86-64: amd64, x86_64 - xcore, // XCore: xcore - xtensa, // Tensilica: Xtensa - nvptx, // NVPTX: 32-bit - nvptx64, // NVPTX: 64-bit - le32, // le32: generic little-endian 32-bit CPU (PNaCl) - le64, // le64: generic little-endian 64-bit CPU (PNaCl) - amdil, // AMDIL - amdil64, // AMDIL with 64-bit pointers - hsail, // AMD HSAIL - hsail64, // AMD HSAIL with 64-bit pointers - spir, // SPIR: standard portable IR for OpenCL 32-bit version - spir64, // SPIR: standard portable IR for OpenCL 64-bit version - spirv, // SPIR-V with logical memory layout. - spirv32, // SPIR-V with 32-bit pointers - spirv64, // SPIR-V with 64-bit pointers - kalimba, // Kalimba: generic kalimba - shave, // SHAVE: Movidius vector VLIW processors - lanai, // Lanai: Lanai 32-bit - wasm32, // WebAssembly with 32-bit pointers - wasm64, // WebAssembly with 64-bit pointers + arm, // ARM (little endian): arm, armv.*, xscale + armeb, // ARM (big endian): armeb + aarch64, // AArch64 (little endian): aarch64 + aarch64_be, // AArch64 (big endian): aarch64_be + aarch64_32, // AArch64 (little endian) ILP32: aarch64_32 + arc, // ARC: Synopsys ARC + avr, // AVR: Atmel AVR microcontroller + bpfel, // eBPF or extended BPF or 64-bit BPF (little endian) + bpfeb, // eBPF or extended BPF or 64-bit BPF (big endian) + csky, // CSKY: csky + dxil, // DXIL 32-bit DirectX bytecode + hexagon, // Hexagon: hexagon + loongarch32, // LoongArch (32-bit): loongarch32 + loongarch64, // LoongArch (64-bit): loongarch64 + m68k, // M68k: Motorola 680x0 family + mips, // MIPS: mips, mipsallegrex, mipsr6 + mipsel, // MIPSEL: mipsel, mipsallegrexe, mipsr6el + mips64, // MIPS64: mips64, mips64r6, mipsn32, mipsn32r6 + mips64el, // MIPS64EL: mips64el, mips64r6el, mipsn32el, mipsn32r6el + msp430, // MSP430: msp430 + ppc, // PPC: powerpc + ppcle, // PPCLE: powerpc (little endian) + ppc64, // PPC64: powerpc64, ppu + ppc64le, // PPC64LE: powerpc64le + r600, // R600: AMD GPUs HD2XXX - HD6XXX + amdgcn, // AMDGCN: AMD GCN GPUs + riscv32, // RISC-V (32-bit): riscv32 + riscv64, // RISC-V (64-bit): riscv64 + sparc, // Sparc: sparc + sparcv9, // Sparcv9: Sparcv9 + sparcel, // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant + systemz, // SystemZ: s390x + tce, // TCE (http://tce.cs.tut.fi/): tce + tcele, // TCE little endian (http://tce.cs.tut.fi/): tcele + thumb, // Thumb (little endian): thumb, thumbv.* + thumbeb, // Thumb (big endian): thumbeb + x86, // X86: i[3-9]86 + x86_64, // X86-64: amd64, x86_64 + xcore, // XCore: xcore + xtensa, // Tensilica: Xtensa + nvptx, // NVPTX: 32-bit + nvptx64, // NVPTX: 64-bit + le32, // le32: generic little-endian 32-bit CPU (PNaCl) + le64, // le64: generic little-endian 64-bit CPU (PNaCl) + amdil, // AMDIL + amdil64, // AMDIL with 64-bit pointers + hsail, // AMD HSAIL + hsail64, // AMD HSAIL with 64-bit pointers + spir, // SPIR: standard portable IR for OpenCL 32-bit version + spir64, // SPIR: standard portable IR for OpenCL 64-bit version + spirv, // SPIR-V with logical memory layout. + spirv32, // SPIR-V with 32-bit pointers + spirv64, // SPIR-V with 64-bit pointers + kalimba, // Kalimba: generic kalimba + shave, // SHAVE: Movidius vector VLIW processors + lanai, // Lanai: Lanai 32-bit + wasm32, // WebAssembly with 32-bit pointers + wasm64, // WebAssembly with 64-bit pointers renderscript32, // 32-bit RenderScript renderscript64, // 64-bit RenderScript ve, // NEC SX-Aurora Vector Engine @@ -193,7 +193,7 @@ class Triple { IOS, KFreeBSD, Linux, - Lv2, // PS3 + Lv2, // PS3 MacOSX, NetBSD, OpenBSD, @@ -203,17 +203,17 @@ class Triple { ZOS, Haiku, RTEMS, - NaCl, // Native Client + NaCl, // Native Client AIX, - CUDA, // NVIDIA CUDA - NVCL, // NVIDIA OpenCL - AMDHSA, // AMD HSA Runtime + CUDA, // NVIDIA CUDA + NVCL, // NVIDIA OpenCL + AMDHSA, // AMD HSA Runtime PS4, PS5, ELFIAMCU, - TvOS, // Apple tvOS - WatchOS, // Apple watchOS - DriverKit, // Apple DriverKit + TvOS, // Apple tvOS + WatchOS, // Apple watchOS + DriverKit, // Apple DriverKit Mesa3D, AMDPAL, // AMD PAL Runtime HermitCore, // HermitCore Unikernel/Multikernel @@ -252,7 +252,7 @@ class Triple { Cygnus, CoreCLR, Simulator, // Simulator variants of other systems, e.g., Apple's iOS - MacABI, // Mac Catalyst variant of Apple's iOS deployment target. + MacABI, // Mac Catalyst variant of Apple's iOS deployment target. // Shader Stages // The order of these values matters, and must be kept in sync with the @@ -332,9 +332,7 @@ class Triple { ObjectFormat == Other.ObjectFormat; } - bool operator!=(const Triple &Other) const { - return !(*this == Other); - } + bool operator!=(const Triple &Other) const { return !(*this == Other); } /// @} /// @name Normalization @@ -366,9 +364,7 @@ class Triple { OSType getOS() const { return OS; } /// Does this triple have the optional environment (fourth) component? - bool hasEnvironment() const { - return getEnvironmentName() != ""; - } + bool hasEnvironment() const { return getEnvironmentName() != ""; } /// Get the parsed environment type of this triple. EnvironmentType getEnvironment() const { return Environment; } @@ -490,23 +486,15 @@ class Triple { /// changes, i.e., if the two operating systems diverge or their version /// numbers get out of sync, that will need to be changed. /// watchOS has completely different version numbers so it is not included. - bool isiOS() const { - return getOS() == Triple::IOS || isTvOS(); - } + bool isiOS() const { return getOS() == Triple::IOS || isTvOS(); } /// Is this an Apple tvOS triple. - bool isTvOS() const { - return getOS() == Triple::TvOS; - } + bool isTvOS() const { return getOS() == Triple::TvOS; } /// Is this an Apple watchOS triple. - bool isWatchOS() const { - return getOS() == Triple::WatchOS; - } + bool isWatchOS() const { return getOS() == Triple::WatchOS; } - bool isWatchABI() const { - return getSubArch() == Triple::ARMSubArch_v7k; - } + bool isWatchABI() const { return getSubArch() == Triple::ARMSubArch_v7k; } /// Is this an Apple DriverKit triple. bool isDriverKit() const { return getOS() == Triple::DriverKit; } @@ -532,31 +520,19 @@ class Triple { isMacCatalystEnvironment())); } - bool isOSNetBSD() const { - return getOS() == Triple::NetBSD; - } + bool isOSNetBSD() const { return getOS() == Triple::NetBSD; } - bool isOSOpenBSD() const { - return getOS() == Triple::OpenBSD; - } + bool isOSOpenBSD() const { return getOS() == Triple::OpenBSD; } - bool isOSFreeBSD() const { - return getOS() == Triple::FreeBSD; - } + bool isOSFreeBSD() const { return getOS() == Triple::FreeBSD; } - bool isOSFuchsia() const { - return getOS() == Triple::Fuchsia; - } + bool isOSFuchsia() const { return getOS() == Triple::Fuchsia; } bool isOSDragonFly() const { return getOS() == Triple::DragonFly; } - bool isOSSolaris() const { - return getOS() == Triple::Solaris; - } + bool isOSSolaris() const { return getOS() == Triple::Solaris; } - bool isOSIAMCU() const { - return getOS() == Triple::ELFIAMCU; - } + bool isOSIAMCU() const { return getOS() == Triple::ELFIAMCU; } bool isOSUnknown() const { return getOS() == Triple::UnknownOS; } @@ -570,19 +546,13 @@ class Triple { } /// Tests whether the OS is Haiku. - bool isOSHaiku() const { - return getOS() == Triple::Haiku; - } + bool isOSHaiku() const { return getOS() == Triple::Haiku; } /// Tests whether the OS is UEFI. - bool isUEFI() const { - return getOS() == Triple::UEFI; - } + bool isUEFI() const { return getOS() == Triple::UEFI; } /// Tests whether the OS is Windows. - bool isOSWindows() const { - return getOS() == Triple::Win32; - } + bool isOSWindows() const { return getOS() == Triple::Win32; } /// Checks if the environment is MSVC. bool isKnownWindowsMSVCEnvironment() const { @@ -629,34 +599,22 @@ class Triple { } /// Tests whether the OS is NaCl (Native Client) - bool isOSNaCl() const { - return getOS() == Triple::NaCl; - } + bool isOSNaCl() const { return getOS() == Triple::NaCl; } /// Tests whether the OS is Linux. - bool isOSLinux() const { - return getOS() == Triple::Linux; - } + bool isOSLinux() const { return getOS() == Triple::Linux; } /// Tests whether the OS is kFreeBSD. - bool isOSKFreeBSD() const { - return getOS() == Triple::KFreeBSD; - } + bool isOSKFreeBSD() const { return getOS() == Triple::KFreeBSD; } /// Tests whether the OS is Hurd. - bool isOSHurd() const { - return getOS() == Triple::Hurd; - } + bool isOSHurd() const { return getOS() == Triple::Hurd; } /// Tests whether the OS is WASI. - bool isOSWASI() const { - return getOS() == Triple::WASI; - } + bool isOSWASI() const { return getOS() == Triple::WASI; } /// Tests whether the OS is Emscripten. - bool isOSEmscripten() const { - return getOS() == Triple::Emscripten; - } + bool isOSEmscripten() const { return getOS() == Triple::Emscripten; } /// Tests whether the OS uses glibc. bool isOSGlibc() const { @@ -666,41 +624,27 @@ class Triple { } /// Tests whether the OS is AIX. - bool isOSAIX() const { - return getOS() == Triple::AIX; - } + bool isOSAIX() const { return getOS() == Triple::AIX; } - bool isOSSerenity() const { - return getOS() == Triple::Serenity; - } + bool isOSSerenity() const { return getOS() == Triple::Serenity; } /// Tests whether the OS uses the ELF binary format. - bool isOSBinFormatELF() const { - return getObjectFormat() == Triple::ELF; - } + bool isOSBinFormatELF() const { return getObjectFormat() == Triple::ELF; } /// Tests whether the OS uses the COFF binary format. - bool isOSBinFormatCOFF() const { - return getObjectFormat() == Triple::COFF; - } + bool isOSBinFormatCOFF() const { return getObjectFormat() == Triple::COFF; } /// Tests whether the OS uses the GOFF binary format. bool isOSBinFormatGOFF() const { return getObjectFormat() == Triple::GOFF; } /// Tests whether the environment is MachO. - bool isOSBinFormatMachO() const { - return getObjectFormat() == Triple::MachO; - } + bool isOSBinFormatMachO() const { return getObjectFormat() == Triple::MachO; } /// Tests whether the OS uses the Wasm binary format. - bool isOSBinFormatWasm() const { - return getObjectFormat() == Triple::Wasm; - } + bool isOSBinFormatWasm() const { return getObjectFormat() == Triple::Wasm; } /// Tests whether the OS uses the XCOFF binary format. - bool isOSBinFormatXCOFF() const { - return getObjectFormat() == Triple::XCOFF; - } + bool isOSBinFormatXCOFF() const { return getObjectFormat() == Triple::XCOFF; } /// Tests whether the OS uses the DXContainer binary format. bool isOSBinFormatDXContainer() const { @@ -709,16 +653,14 @@ class Triple { /// Tests whether the target is the PS4 platform. bool isPS4() const { - return getArch() == Triple::x86_64 && - getVendor() == Triple::SCEI && + return getArch() == Triple::x86_64 && getVendor() == Triple::SCEI && getOS() == Triple::PS4; } /// Tests whether the target is the PS5 platform. bool isPS5() const { - return getArch() == Triple::x86_64 && - getVendor() == Triple::SCEI && - getOS() == Triple::PS5; + return getArch() == Triple::x86_64 && getVendor() == Triple::SCEI && + getOS() == Triple::PS5; } /// Tests whether the target is the PS4 or PS5 platform. @@ -757,13 +699,9 @@ class Triple { bool isOSLiteOS() const { return getOS() == Triple::LiteOS; } /// Tests whether the target is DXIL. - bool isDXIL() const { - return getArch() == Triple::dxil; - } + bool isDXIL() const { return getArch() == Triple::dxil; } - bool isShaderModelOS() const { - return getOS() == Triple::ShaderModel; - } + bool isShaderModelOS() const { return getOS() == Triple::ShaderModel; } bool isShaderStageEnvironment() const { EnvironmentType Env = getEnvironment(); @@ -789,9 +727,7 @@ class Triple { } /// Tests whether the target is SPIR-V Logical - bool isSPIRVLogical() const { - return getArch() == Triple::spirv; - } + bool isSPIRVLogical() const { return getArch() == Triple::spirv; } /// Tests whether the target is NVPTX (32- or 64-bit). bool isNVPTX() const { @@ -902,9 +838,7 @@ class Triple { } /// Tests whether the target is MIPS (little and big endian, 32- or 64-bit). - bool isMIPS() const { - return isMIPS32() || isMIPS64(); - } + bool isMIPS() const { return isMIPS32() || isMIPS64(); } /// Tests whether the target is PowerPC (32- or 64-bit LE or BE). bool isPPC() const { @@ -960,9 +894,7 @@ class Triple { bool isSPARC() const { return isSPARC32() || isSPARC64(); } /// Tests whether the target is SystemZ. - bool isSystemZ() const { - return getArch() == Triple::systemz; - } + bool isSystemZ() const { return getArch() == Triple::systemz; } /// Tests whether the target is x86 (32- or 64-bit). bool isX86() const { @@ -970,9 +902,7 @@ class Triple { } /// Tests whether the target is VE - bool isVE() const { - return getArch() == Triple::ve; - } + bool isVE() const { return getArch() == Triple::ve; } /// Tests whether the target is wasm (32- and 64-bit). bool isWasm() const { @@ -980,9 +910,7 @@ class Triple { } // Tests whether the target is CSKY - bool isCSKY() const { - return getArch() == Triple::csky; - } + bool isCSKY() const { return getArch() == Triple::csky; } /// Tests whether the target is the Apple "arm64e" AArch64 subarch. bool isArm64e() const { @@ -1012,7 +940,7 @@ class Triple { /// Note: Android API level 29 (10) introduced ELF TLS. bool hasDefaultEmulatedTLS() const { return (isAndroid() && isAndroidVersionLT(29)) || isOSOpenBSD() || - isWindowsCygwinEnvironment() || isOHOSFamily(); + isOSCygMing() || isOHOSFamily(); } /// Tests whether the target uses -data-sections as default. @@ -1157,7 +1085,6 @@ class Triple { const VersionTuple &Version); }; -} // End llvm namespace - +} // namespace llvm #endif diff --git a/llvm/lib/Support/Unix/Unix.h b/llvm/lib/Support/Unix/Unix.h index 1599241a344af..ddeb72c7adb32 100644 --- a/llvm/lib/Support/Unix/Unix.h +++ b/llvm/lib/Support/Unix/Unix.h @@ -1,4 +1,5 @@ -//===- llvm/Support/Unix/Unix.h - Common Unix Include File -------*- C++ -*-===// +//===- llvm/Support/Unix/Unix.h - Common Unix Include File -------*- C++ +//-*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -37,16 +38,16 @@ #endif #ifdef HAVE_SYS_TIME_H -# include +#include #endif #include #ifdef HAVE_DLFCN_H -# include +#include #endif #ifdef HAVE_FCNTL_H -# include +#include #endif /// This function builds an error message into \p ErrMsg using the \p prefix @@ -56,8 +57,8 @@ /// /// If the error number can be converted to a string, it will be /// separated from prefix by ": ". -static inline bool MakeErrMsg( - std::string* ErrMsg, const std::string& prefix, int errnum = -1) { +static inline bool MakeErrMsg(std::string *ErrMsg, const std::string &prefix, + int errnum = -1) { if (!ErrMsg) return true; if (errnum == -1) @@ -78,7 +79,9 @@ namespace sys { /// Convert a struct timeval to a duration. Note that timeval can be used both /// as a time point and a duration. Be sure to check what the input represents. -inline std::chrono::microseconds toDuration(const struct timeval &TV) { + +template +inline std::chrono::microseconds toDuration(const timevaltype &TV) { return std::chrono::seconds(TV.tv_sec) + std::chrono::microseconds(TV.tv_usec); } diff --git a/mlir/lib/ExecutionEngine/CRunnerUtils.cpp b/mlir/lib/ExecutionEngine/CRunnerUtils.cpp index e28e75eb11030..8aa9ad8693ecb 100644 --- a/mlir/lib/ExecutionEngine/CRunnerUtils.cpp +++ b/mlir/lib/ExecutionEngine/CRunnerUtils.cpp @@ -16,7 +16,7 @@ #include "mlir/ExecutionEngine/Msan.h" #ifndef _WIN32 -#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || \ +#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || \ defined(__DragonFly__) #include #else @@ -139,7 +139,7 @@ extern "C" void *mlirAlloc(uint64_t size) { return malloc(size); } extern "C" void *mlirAlignedAlloc(uint64_t alignment, uint64_t size) { #ifdef _WIN32 return _aligned_malloc(size, alignment); -#elif defined(__APPLE__) +#elif defined(__APPLE__) || (defined(__ANDROID_API__) && __ANDROID_API__ <= 28) // aligned_alloc was added in MacOS 10.15. Fall back to posix_memalign to also // support older versions. void *result = nullptr; From 62f660b5efb98aea64ff4268120edb7710a6c4db Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 6 Jan 2024 20:28:41 -0500 Subject: [PATCH 065/111] CMake's android detection is not correct --- lldb/source/Host/CMakeLists.txt | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/lldb/source/Host/CMakeLists.txt b/lldb/source/Host/CMakeLists.txt index fe6e539f758fd..2f30ebf608dca 100644 --- a/lldb/source/Host/CMakeLists.txt +++ b/lldb/source/Host/CMakeLists.txt @@ -108,13 +108,9 @@ else() linux/HostInfoLinux.cpp linux/LibcGlue.cpp linux/Support.cpp + android/HostInfoAndroid.cpp + android/LibcGlue.cpp ) - if (CMAKE_SYSTEM_NAME MATCHES "Android") - add_host_subdirectory(android - android/HostInfoAndroid.cpp - android/LibcGlue.cpp - ) - endif() elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD") add_host_subdirectory(freebsd freebsd/Host.cpp From 41a1007795b8aa4f9d6f437ac59217f8c1baab1c Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 7 Jan 2024 05:33:43 -0500 Subject: [PATCH 066/111] partial fix of wasminstrmemtag --- .../WebAssembly/WebAssemblyInstrMemtag.td | 130 +++++++++--------- 1 file changed, 65 insertions(+), 65 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 222d079913715..346c631e18c91 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -13,104 +13,104 @@ multiclass MemoryTaggingOps { -defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src), - (outs), (ins i32imm:$flags), +defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src), + (outs), (ins table32_op:$table), [(set rc:$dst, - (int_wasm_memory_randomtag i32imm:$flags, rc:$src))], - "memory.randomtag\t$dst, $flags, $src", - "memory.randomtag\t$flags", + (int_wasm_memory_randomtag table32_op:$table, rc:$src))], + "memory.randomtag\t$dst, $table, $src", + "memory.randomtag\t$table", 0xfc20>; -defm MEMORY_COPYTAG_A#B: I<(outs rc:$dstwsrctag), (ins i32imm:$flags, rc:$dst, rc:$src), - (outs), (ins i32imm:$flags), +defm MEMORY_COPYTAG_A#B: I<(outs rc:$dstwsrctag), (ins table32_op:$table, rc:$dst, rc:$src), + (outs), (ins table32_op:$table), [(set rc:$dstwsrctag, - (int_wasm_memory_copytag i32imm:$flags, rc:$dst, rc:$src))], - "memory.copytag\t$dstwsrctag, $flags, $dst, $src", - "memory.copytag\t$flags", + (int_wasm_memory_copytag table32_op:$table, rc:$dst, rc:$src))], + "memory.copytag\t$dstwsrctag, $table, $dst, $src", + "memory.copytag\t$table", 0xfc21>; -defm MEMORY_SUBTAG_A#B: I<(outs rc:$diff), (ins i32imm:$flags, rc:$minuendptr, rc:$subtrahendptr), - (outs), (ins i32imm:$flags), +defm MEMORY_SUBTAG_A#B: I<(outs rc:$diff), (ins table32_op:$table, rc:$minuendptr, rc:$subtrahendptr), + (outs), (ins table32_op:$table), [(set rc:$diff, - (int_wasm_memory_subtag i32imm:$flags, rc:$minuendptr, rc:$subtrahendptr))], - "memory.subtag\t$diff, $flags, $minuendptr, $subtrahendptr", - "memory.subtag\t$flags", + (int_wasm_memory_subtag table32_op:$table, rc:$minuendptr, rc:$subtrahendptr))], + "memory.subtag\t$diff, $table, $minuendptr, $subtrahendptr", + "memory.subtag\t$table", 0xfc22>; -defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins i32imm:$flags, rc:$src), - (outs), (ins i32imm:$flags), +defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins table32_op:$table, rc:$src), + (outs), (ins table32_op:$table), [(set rc:$taggedptr, - (int_wasm_memory_loadtag i32imm:$flags, rc:$src))], - "memory.loadtag\t$taggedptr, $flags, $src", - "memory.loadtag\t$flags", + (int_wasm_memory_loadtag table32_op:$table, rc:$src))], + "memory.loadtag\t$taggedptr, $table, $src", + "memory.loadtag\t$table", 0xfc23>; -defm MEMORY_STORETAG_A#B: I<(outs), (ins i32imm:$flags, rc:$src, rc:$b16), - (outs), (ins i32imm:$flags), - [(int_wasm_memory_storetag i32imm:$flags, rc:$src, rc:$b16)], - "memory.storetag\t$flags, $src, $b16", - "memory.storetag\t$flags", +defm MEMORY_STORETAG_A#B: I<(outs), (ins table32_op:$table, rc:$src, rc:$b16), + (outs), (ins table32_op:$table), + [(int_wasm_memory_storetag table32_op:$table, rc:$src, rc:$b16)], + "memory.storetag\t$table, $src, $b16", + "memory.storetag\t$table", 0xfc24>; -defm MEMORY_STOREZTAG_A#B: I<(outs), (ins i32imm:$flags, rc:$src, rc:$b16), - (outs), (ins i32imm:$flags), - [(int_wasm_memory_storeztag i32imm:$flags, rc:$src, rc:$b16)], - "memory.storeztag\t$flags, $src, $b16", - "memory.storeztag\t$flags", +defm MEMORY_STOREZTAG_A#B: I<(outs), (ins table32_op:$table, rc:$src, rc:$b16), + (outs), (ins table32_op:$table), + [(int_wasm_memory_storeztag table32_op:$table, rc:$src, rc:$b16)], + "memory.storeztag\t$table, $src, $b16", + "memory.storeztag\t$table", 0xfc25>; -defm MEMORY_STORE1TAG_A#B: I<(outs), (ins i32imm:$flags, rc:$src, rc:$b16), - (outs), (ins i32imm:$flags), - [(int_wasm_memory_store1tag i32imm:$flags, rc:$src, rc:$b16)], - "memory.store1tag\t$flags, $src, $b16", - "memory.store1tag\t$flags", +defm MEMORY_STORE1TAG_A#B: I<(outs), (ins table32_op:$table, rc:$src, rc:$b16), + (outs), (ins table32_op:$table), + [(int_wasm_memory_store1tag table32_op:$table, rc:$src, rc:$b16)], + "memory.store1tag\t$table, $src, $b16", + "memory.store1tag\t$table", 0xfc26>; -defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins i32imm:$flags, rc:$src, rc:$b16), - (outs), (ins i32imm:$flags), - [(int_wasm_memory_storez1tag i32imm:$flags, rc:$src, rc:$b16)], - "memory.storez1tag\t$flags, $src, $b16", - "memory.storez1tag\t$flags", +defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins table32_op:$table, rc:$src, rc:$b16), + (outs), (ins table32_op:$table), + [(int_wasm_memory_storez1tag table32_op:$table, rc:$src, rc:$b16)], + "memory.storez1tag\t$table, $src, $b16", + "memory.storez1tag\t$table", 0xfc27>; -defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, rc:$b16), - (outs), (ins i32imm:$flags), +defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src, rc:$b16), + (outs), (ins table32_op:$table), [(set rc:$dst, - (int_wasm_memory_randomstoretag rc:$src, i32imm:$flags, rc:$b16))], - "memory.randomstoretag\t$dst, $flags, $src, $b16", - "memory.randomstoretag\t$flags", + (int_wasm_memory_randomstoretag table32_op:$table, rc:$src, rc:$b16))], + "memory.randomstoretag\t$dst, $table, $src, $b16", + "memory.randomstoretag\t$table", 0xfc28>; -defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, rc:$b16), - (outs), (ins i32imm:$flags), +defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src, rc:$b16), + (outs), (ins table32_op:$table), [(set rc:$dst, - (int_wasm_memory_randomstoreztag rc:$src, i32imm:$flags, rc:$b16))], - "memory.randomstoreztag\t$dst, $flags, $src, $b16", - "memory.randomstoreztag\t$flags", + (int_wasm_memory_randomstoreztag table32_op:$table, rc:$src, rc:$b16))], + "memory.randomstoreztag\t$dst, $src, $table, $b16", + "memory.randomstoreztag\t$table", 0xfc29>; -defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, rc:$b16), - (outs), (ins i32imm:$flags), +defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src, rc:$b16), + (outs), (ins table32_op:$table), [(set rc:$dst, - (int_wasm_memory_randomstore1tag rc:$src, i32imm:$flags, rc:$b16))], - "memory.randomstore1tag\t$dst, $flags, $src, $b16", - "memory.randomstore1tag\t$flags", + (int_wasm_memory_randomstore1tag table32_op:$table, rc:$src, rc:$b16))], + "memory.randomstore1tag\t$dst, $table, $src, $b16", + "memory.randomstore1tag\t$table", 0xfc2a>; -defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$flags, rc:$src, rc:$b16), - (outs), (ins i32imm:$flags), +defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src, rc:$b16), + (outs), (ins table32_op:$table), [(set rc:$dst, - (int_wasm_memory_randomstorez1tag rc:$src, i32imm:$flags, rc:$b16))], - "memory.randomstorez1tag\t$dst, $flags, $src, $b16", - "memory.randomstorez1tag\t$flags", + (int_wasm_memory_randomstorez1tag table32_op:$table, rc:$src, rc:$b16))], + "memory.randomstorez1tag\t$dst, $table, $src, $b16", + "memory.randomstorez1tag\t$table", 0xfc2b>; -defm MEMORY_ADDNEXTTAG_A#B: I<(outs rc:$nexttaggedptr), (ins i32imm:$flags, rc:$taggedptr, rc:$offset), - (outs), (ins i32imm:$flags), +defm MEMORY_ADDNEXTTAG_A#B: I<(outs rc:$nexttaggedptr), (ins table32_op:$table, rc:$taggedptr, rc:$offset), + (outs), (ins table32_op:$table), [(set rc:$nexttaggedptr, - (int_wasm_memory_addnexttag i32imm:$flags, rc:$taggedptr, rc:$offset))], - "memory.addnexttag\t$nexttaggedptr, $flags, $taggedptr, $offset", - "memory.addnexttag\t$flags", + (int_wasm_memory_addnexttag table32_op:$table, rc:$taggedptr, rc:$offset))], + "memory.addnexttag\t$nexttaggedptr, $table, $taggedptr, $offset", + "memory.addnexttag\t$table", 0xfc2c>; } From 2b2b15ccc75150387119b2ed0b6f02867433288b Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 7 Jan 2024 05:47:21 -0500 Subject: [PATCH 067/111] use wasmwrapper on tglobaladdr --- .../WebAssembly/WebAssemblyInstrMemtag.td | 26 +++++++++---------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 346c631e18c91..a57ca103364ea 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -16,7 +16,7 @@ multiclass MemoryTaggingOps { defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src), (outs), (ins table32_op:$table), [(set rc:$dst, - (int_wasm_memory_randomtag table32_op:$table, rc:$src))], + (int_wasm_memory_randomtag (WebAssemblyWrapper tglobaladdr:$table), rc:$src))], "memory.randomtag\t$dst, $table, $src", "memory.randomtag\t$table", 0xfc20>; @@ -24,7 +24,7 @@ defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src), defm MEMORY_COPYTAG_A#B: I<(outs rc:$dstwsrctag), (ins table32_op:$table, rc:$dst, rc:$src), (outs), (ins table32_op:$table), [(set rc:$dstwsrctag, - (int_wasm_memory_copytag table32_op:$table, rc:$dst, rc:$src))], + (int_wasm_memory_copytag (WebAssemblyWrapper tglobaladdr:$table), rc:$dst, rc:$src))], "memory.copytag\t$dstwsrctag, $table, $dst, $src", "memory.copytag\t$table", 0xfc21>; @@ -32,7 +32,7 @@ defm MEMORY_COPYTAG_A#B: I<(outs rc:$dstwsrctag), (ins table32_op:$table, rc:$ds defm MEMORY_SUBTAG_A#B: I<(outs rc:$diff), (ins table32_op:$table, rc:$minuendptr, rc:$subtrahendptr), (outs), (ins table32_op:$table), [(set rc:$diff, - (int_wasm_memory_subtag table32_op:$table, rc:$minuendptr, rc:$subtrahendptr))], + (int_wasm_memory_subtag (WebAssemblyWrapper tglobaladdr:$table), rc:$minuendptr, rc:$subtrahendptr))], "memory.subtag\t$diff, $table, $minuendptr, $subtrahendptr", "memory.subtag\t$table", 0xfc22>; @@ -40,35 +40,35 @@ defm MEMORY_SUBTAG_A#B: I<(outs rc:$diff), (ins table32_op:$table, rc:$minuendpt defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins table32_op:$table, rc:$src), (outs), (ins table32_op:$table), [(set rc:$taggedptr, - (int_wasm_memory_loadtag table32_op:$table, rc:$src))], + (int_wasm_memory_loadtag (WebAssemblyWrapper tglobaladdr:$table), rc:$src))], "memory.loadtag\t$taggedptr, $table, $src", "memory.loadtag\t$table", 0xfc23>; defm MEMORY_STORETAG_A#B: I<(outs), (ins table32_op:$table, rc:$src, rc:$b16), (outs), (ins table32_op:$table), - [(int_wasm_memory_storetag table32_op:$table, rc:$src, rc:$b16)], + [(int_wasm_memory_storetag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16)], "memory.storetag\t$table, $src, $b16", "memory.storetag\t$table", 0xfc24>; defm MEMORY_STOREZTAG_A#B: I<(outs), (ins table32_op:$table, rc:$src, rc:$b16), (outs), (ins table32_op:$table), - [(int_wasm_memory_storeztag table32_op:$table, rc:$src, rc:$b16)], + [(int_wasm_memory_storeztag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16)], "memory.storeztag\t$table, $src, $b16", "memory.storeztag\t$table", 0xfc25>; defm MEMORY_STORE1TAG_A#B: I<(outs), (ins table32_op:$table, rc:$src, rc:$b16), (outs), (ins table32_op:$table), - [(int_wasm_memory_store1tag table32_op:$table, rc:$src, rc:$b16)], + [(int_wasm_memory_store1tag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16)], "memory.store1tag\t$table, $src, $b16", "memory.store1tag\t$table", 0xfc26>; defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins table32_op:$table, rc:$src, rc:$b16), (outs), (ins table32_op:$table), - [(int_wasm_memory_storez1tag table32_op:$table, rc:$src, rc:$b16)], + [(int_wasm_memory_storez1tag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16)], "memory.storez1tag\t$table, $src, $b16", "memory.storez1tag\t$table", 0xfc27>; @@ -76,7 +76,7 @@ defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins table32_op:$table, rc:$src, rc:$b16), defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src, rc:$b16), (outs), (ins table32_op:$table), [(set rc:$dst, - (int_wasm_memory_randomstoretag table32_op:$table, rc:$src, rc:$b16))], + (int_wasm_memory_randomstoretag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16))], "memory.randomstoretag\t$dst, $table, $src, $b16", "memory.randomstoretag\t$table", 0xfc28>; @@ -84,7 +84,7 @@ defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$sr defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src, rc:$b16), (outs), (ins table32_op:$table), [(set rc:$dst, - (int_wasm_memory_randomstoreztag table32_op:$table, rc:$src, rc:$b16))], + (int_wasm_memory_randomstoreztag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16))], "memory.randomstoreztag\t$dst, $src, $table, $b16", "memory.randomstoreztag\t$table", 0xfc29>; @@ -92,7 +92,7 @@ defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$s defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src, rc:$b16), (outs), (ins table32_op:$table), [(set rc:$dst, - (int_wasm_memory_randomstore1tag table32_op:$table, rc:$src, rc:$b16))], + (int_wasm_memory_randomstore1tag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16))], "memory.randomstore1tag\t$dst, $table, $src, $b16", "memory.randomstore1tag\t$table", 0xfc2a>; @@ -100,7 +100,7 @@ defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$s defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src, rc:$b16), (outs), (ins table32_op:$table), [(set rc:$dst, - (int_wasm_memory_randomstorez1tag table32_op:$table, rc:$src, rc:$b16))], + (int_wasm_memory_randomstorez1tag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16))], "memory.randomstorez1tag\t$dst, $table, $src, $b16", "memory.randomstorez1tag\t$table", 0xfc2b>; @@ -108,7 +108,7 @@ defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$ defm MEMORY_ADDNEXTTAG_A#B: I<(outs rc:$nexttaggedptr), (ins table32_op:$table, rc:$taggedptr, rc:$offset), (outs), (ins table32_op:$table), [(set rc:$nexttaggedptr, - (int_wasm_memory_addnexttag table32_op:$table, rc:$taggedptr, rc:$offset))], + (int_wasm_memory_addnexttag (WebAssemblyWrapper tglobaladdr:$table), rc:$taggedptr, rc:$offset))], "memory.addnexttag\t$nexttaggedptr, $table, $taggedptr, $offset", "memory.addnexttag\t$table", 0xfc2c>; From 76aa6b5841e59b8f5fd3085b1124089be62c830d Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 7 Jan 2024 10:52:38 -0500 Subject: [PATCH 068/111] add memtag intrinsics --- llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 26 +++++++++---------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index b188abf3008c8..c92e5385b758c 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -346,42 +346,42 @@ def int_wasm_tls_base : //===----------------------------------------------------------------------===// def int_wasm_memory_randomtag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.randomtag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.randomtag">; def int_wasm_memory_copytag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.copytag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.copytag">; def int_wasm_memory_subtag : - DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.subtag">; + DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_table_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.subtag">; def int_wasm_memory_loadtag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrReadMem], "llvm.wasm.memory.loadtag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty], [IntrReadMem], "llvm.wasm.memory.loadtag">; def int_wasm_memory_storetag : - DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storetag">; + DefaultAttrsIntrinsic<[], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storetag">; def int_wasm_memory_storeztag : - DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storeztag">; + DefaultAttrsIntrinsic<[], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storeztag">; def int_wasm_memory_store1tag : - DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.store1tag">; + DefaultAttrsIntrinsic<[], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.store1tag">; def int_wasm_memory_storez1tag : - DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storez1tag">; + DefaultAttrsIntrinsic<[], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storez1tag">; def int_wasm_memory_randomstoretag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoretag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoretag">; def int_wasm_memory_randomstoreztag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoreztag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoreztag">; def int_wasm_memory_randomstore1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstore1tag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstore1tag">; def int_wasm_memory_randomstorez1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstorez1tag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstorez1tag">; def int_wasm_memory_addnexttag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memory.addnexttag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memory.addnexttag">; } // TargetPrefix = "wasm" From 402ded9f0bff46ddd6c919edd8b8258b04c0c4d1 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 7 Jan 2024 13:04:02 -0500 Subject: [PATCH 069/111] Fix intrinsics --- clang/lib/CodeGen/CGBuiltin.cpp | 52 +++++++++---------- llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 26 +++++----- 2 files changed, 39 insertions(+), 39 deletions(-) diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 2e45dac5c7cdc..abc2ac51bf55e 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -20412,92 +20412,92 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, } case WebAssembly::BI__builtin_wasm_memory_randomtag: { Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomtag); - Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); - return Builder.CreateCall(Callee, {Table, Ptr}); + return Builder.CreateCall(Callee, {Index, Ptr}); } case WebAssembly::BI__builtin_wasm_memory_copytag: { Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_copytag); - Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr0 = EmitScalarExpr(E->getArg(1)); Value *Ptr1 = EmitScalarExpr(E->getArg(2)); - return Builder.CreateCall(Callee, {Table, Ptr0, Ptr1}); + return Builder.CreateCall(Callee, {Index, Ptr0, Ptr1}); } case WebAssembly::BI__builtin_wasm_memory_subtag: { Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_subtag, ConvertType(E->getType())); - Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr0 = EmitScalarExpr(E->getArg(1)); Value *Ptr1 = EmitScalarExpr(E->getArg(2)); - return Builder.CreateCall(Callee, {Table, Ptr0, Ptr1}); + return Builder.CreateCall(Callee, {Index, Ptr0, Ptr1}); } case WebAssembly::BI__builtin_wasm_memory_loadtag: { Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_loadtag); - Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); - return Builder.CreateCall(Callee, {Table, Ptr}); + return Builder.CreateCall(Callee, {Index, Ptr}); } case WebAssembly::BI__builtin_wasm_memory_storetag: { - Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storetag, B16->getType()); - return Builder.CreateCall(Callee, {Table, Ptr, B16}); + return Builder.CreateCall(Callee, {Index, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_storeztag: { - Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storeztag, B16->getType()); - return Builder.CreateCall(Callee, {Table, Ptr, B16}); + return Builder.CreateCall(Callee, {Index, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_store1tag: { - Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_store1tag, B16->getType()); - return Builder.CreateCall(Callee, {Table, Ptr, B16}); + return Builder.CreateCall(Callee, {Index, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_storez1tag: { - Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storez1tag, B16->getType()); - return Builder.CreateCall(Callee, {Table, Ptr, B16}); + return Builder.CreateCall(Callee, {Index, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_randomstoretag: { - Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstoretag, B16->getType()); - return Builder.CreateCall(Callee, {Table, Ptr, B16}); + return Builder.CreateCall(Callee, {Index, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_randomstoreztag: { - Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstoreztag, B16->getType()); - return Builder.CreateCall(Callee, {Table, Ptr, B16}); + return Builder.CreateCall(Callee, {Index, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_randomstore1tag: { - Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstore1tag, B16->getType()); - return Builder.CreateCall(Callee, {Table, Ptr, B16}); + return Builder.CreateCall(Callee, {Index, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_randomstorez1tag: { - Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *B16 = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstorez1tag, B16->getType()); - return Builder.CreateCall(Callee, {Table, Ptr, B16}); + return Builder.CreateCall(Callee, {Index, Ptr, B16}); } case WebAssembly::BI__builtin_wasm_memory_addnexttag: { - Value *Table = EmitScalarExpr(E->getArg(0)); + Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *PtrOffset = EmitScalarExpr(E->getArg(2)); Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_addnexttag, PtrOffset->getType()); - return Builder.CreateCall(Callee, {Table, Ptr, PtrOffset}); + return Builder.CreateCall(Callee, {Index, Ptr, PtrOffset}); } default: return nullptr; diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index c92e5385b758c..b188abf3008c8 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -346,42 +346,42 @@ def int_wasm_tls_base : //===----------------------------------------------------------------------===// def int_wasm_memory_randomtag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.randomtag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.randomtag">; def int_wasm_memory_copytag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.copytag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.copytag">; def int_wasm_memory_subtag : - DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_table_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.subtag">; + DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.subtag">; def int_wasm_memory_loadtag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty], [IntrReadMem], "llvm.wasm.memory.loadtag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrReadMem], "llvm.wasm.memory.loadtag">; def int_wasm_memory_storetag : - DefaultAttrsIntrinsic<[], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storetag">; + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storetag">; def int_wasm_memory_storeztag : - DefaultAttrsIntrinsic<[], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storeztag">; + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storeztag">; def int_wasm_memory_store1tag : - DefaultAttrsIntrinsic<[], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.store1tag">; + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.store1tag">; def int_wasm_memory_storez1tag : - DefaultAttrsIntrinsic<[], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storez1tag">; + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storez1tag">; def int_wasm_memory_randomstoretag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoretag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoretag">; def int_wasm_memory_randomstoreztag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoreztag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoreztag">; def int_wasm_memory_randomstore1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstore1tag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstore1tag">; def int_wasm_memory_randomstorez1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstorez1tag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstorez1tag">; def int_wasm_memory_addnexttag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_table_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memory.addnexttag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memory.addnexttag">; } // TargetPrefix = "wasm" From b546366af57e52d60418c72a4be302af759e2b5f Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 7 Jan 2024 13:11:49 -0500 Subject: [PATCH 070/111] Fixing instrmemtag --- .../WebAssembly/WebAssemblyInstrMemtag.td | 130 +++++++++--------- 1 file changed, 65 insertions(+), 65 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index a57ca103364ea..63cfb5167cace 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -13,104 +13,104 @@ multiclass MemoryTaggingOps { -defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src), - (outs), (ins table32_op:$table), +defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src), + (outs), (ins i32imm:$tableidx), [(set rc:$dst, - (int_wasm_memory_randomtag (WebAssemblyWrapper tglobaladdr:$table), rc:$src))], - "memory.randomtag\t$dst, $table, $src", - "memory.randomtag\t$table", + (int_wasm_memory_randomtag (i32 imm:$tableidx), rc:$src))], + "memory.randomtag\t$dst, $tableidx, $src", + "memory.randomtag\t$tableidx", 0xfc20>; -defm MEMORY_COPYTAG_A#B: I<(outs rc:$dstwsrctag), (ins table32_op:$table, rc:$dst, rc:$src), - (outs), (ins table32_op:$table), +defm MEMORY_COPYTAG_A#B: I<(outs rc:$dstwsrctag), (ins i32imm:$tableidx, rc:$dst, rc:$src), + (outs), (ins i32imm:$tableidx), [(set rc:$dstwsrctag, - (int_wasm_memory_copytag (WebAssemblyWrapper tglobaladdr:$table), rc:$dst, rc:$src))], - "memory.copytag\t$dstwsrctag, $table, $dst, $src", - "memory.copytag\t$table", + (int_wasm_memory_copytag (i32 imm:$tableidx), rc:$dst, rc:$src))], + "memory.copytag\t$dstwsrctag, $tableidx, $dst, $src", + "memory.copytag\t$tableidx", 0xfc21>; -defm MEMORY_SUBTAG_A#B: I<(outs rc:$diff), (ins table32_op:$table, rc:$minuendptr, rc:$subtrahendptr), - (outs), (ins table32_op:$table), +defm MEMORY_SUBTAG_A#B: I<(outs rc:$diff), (ins i32imm:$tableidx, rc:$minuendptr, rc:$subtrahendptr), + (outs), (ins i32imm:$tableidx), [(set rc:$diff, - (int_wasm_memory_subtag (WebAssemblyWrapper tglobaladdr:$table), rc:$minuendptr, rc:$subtrahendptr))], - "memory.subtag\t$diff, $table, $minuendptr, $subtrahendptr", - "memory.subtag\t$table", + (int_wasm_memory_subtag (i32 imm:$tableidx), rc:$minuendptr, rc:$subtrahendptr))], + "memory.subtag\t$diff, $tableidx, $minuendptr, $subtrahendptr", + "memory.subtag\t$tableidx", 0xfc22>; -defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins table32_op:$table, rc:$src), - (outs), (ins table32_op:$table), +defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins i32imm:$tableidx, rc:$src), + (outs), (ins i32imm:$tableidx), [(set rc:$taggedptr, - (int_wasm_memory_loadtag (WebAssemblyWrapper tglobaladdr:$table), rc:$src))], - "memory.loadtag\t$taggedptr, $table, $src", - "memory.loadtag\t$table", + (int_wasm_memory_loadtag (i32 imm:$tableidx), rc:$src))], + "memory.loadtag\t$taggedptr, $tableidx, $src", + "memory.loadtag\t$tableidx", 0xfc23>; -defm MEMORY_STORETAG_A#B: I<(outs), (ins table32_op:$table, rc:$src, rc:$b16), - (outs), (ins table32_op:$table), - [(int_wasm_memory_storetag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16)], - "memory.storetag\t$table, $src, $b16", - "memory.storetag\t$table", +defm MEMORY_STORETAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), + (outs), (ins i32imm:$tableidx), + [(int_wasm_memory_storetag (i32 imm:$tableidx), rc:$src, rc:$b16)], + "memory.storetag\t$tableidx, $src, $b16", + "memory.storetag\t$tableidx", 0xfc24>; -defm MEMORY_STOREZTAG_A#B: I<(outs), (ins table32_op:$table, rc:$src, rc:$b16), - (outs), (ins table32_op:$table), - [(int_wasm_memory_storeztag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16)], - "memory.storeztag\t$table, $src, $b16", - "memory.storeztag\t$table", +defm MEMORY_STOREZTAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), + (outs), (ins i32imm:$tableidx), + [(int_wasm_memory_storeztag (i32 imm:$tableidx), rc:$src, rc:$b16)], + "memory.storeztag\t$tableidx, $src, $b16", + "memory.storeztag\t$tableidx", 0xfc25>; -defm MEMORY_STORE1TAG_A#B: I<(outs), (ins table32_op:$table, rc:$src, rc:$b16), - (outs), (ins table32_op:$table), - [(int_wasm_memory_store1tag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16)], - "memory.store1tag\t$table, $src, $b16", - "memory.store1tag\t$table", +defm MEMORY_STORE1TAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), + (outs), (ins i32imm:$tableidx), + [(int_wasm_memory_store1tag (i32 imm:$tableidx), rc:$src, rc:$b16)], + "memory.store1tag\t$tableidx, $src, $b16", + "memory.store1tag\t$tableidx", 0xfc26>; -defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins table32_op:$table, rc:$src, rc:$b16), - (outs), (ins table32_op:$table), - [(int_wasm_memory_storez1tag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16)], - "memory.storez1tag\t$table, $src, $b16", - "memory.storez1tag\t$table", +defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), + (outs), (ins i32imm:$tableidx), + [(int_wasm_memory_storez1tag (i32 imm:$tableidx), rc:$src, rc:$b16)], + "memory.storez1tag\t$tableidx, $src, $b16", + "memory.storez1tag\t$tableidx", 0xfc27>; -defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src, rc:$b16), - (outs), (ins table32_op:$table), +defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), + (outs), (ins i32imm:$tableidx), [(set rc:$dst, - (int_wasm_memory_randomstoretag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16))], - "memory.randomstoretag\t$dst, $table, $src, $b16", - "memory.randomstoretag\t$table", + (int_wasm_memory_randomstoretag (i32 imm:$tableidx), rc:$src, rc:$b16))], + "memory.randomstoretag\t$dst, $tableidx, $src, $b16", + "memory.randomstoretag\t$tableidx", 0xfc28>; -defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src, rc:$b16), - (outs), (ins table32_op:$table), +defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), + (outs), (ins i32imm:$tableidx), [(set rc:$dst, - (int_wasm_memory_randomstoreztag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16))], - "memory.randomstoreztag\t$dst, $src, $table, $b16", - "memory.randomstoreztag\t$table", + (int_wasm_memory_randomstoreztag (i32 imm:$tableidx), rc:$src, rc:$b16))], + "memory.randomstoreztag\t$dst, $src, $tableidx, $b16", + "memory.randomstoreztag\t$tableidx", 0xfc29>; -defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src, rc:$b16), - (outs), (ins table32_op:$table), +defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), + (outs), (ins i32imm:$tableidx), [(set rc:$dst, - (int_wasm_memory_randomstore1tag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16))], - "memory.randomstore1tag\t$dst, $table, $src, $b16", - "memory.randomstore1tag\t$table", + (int_wasm_memory_randomstore1tag (i32 imm:$tableidx), rc:$src, rc:$b16))], + "memory.randomstore1tag\t$dst, $tableidx, $src, $b16", + "memory.randomstore1tag\t$tableidx", 0xfc2a>; -defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins table32_op:$table, rc:$src, rc:$b16), - (outs), (ins table32_op:$table), +defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), + (outs), (ins i32imm:$tableidx), [(set rc:$dst, - (int_wasm_memory_randomstorez1tag (WebAssemblyWrapper tglobaladdr:$table), rc:$src, rc:$b16))], - "memory.randomstorez1tag\t$dst, $table, $src, $b16", - "memory.randomstorez1tag\t$table", + (int_wasm_memory_randomstorez1tag (i32 imm:$tableidx), rc:$src, rc:$b16))], + "memory.randomstorez1tag\t$dst, $tableidx, $src, $b16", + "memory.randomstorez1tag\t$tableidx", 0xfc2b>; -defm MEMORY_ADDNEXTTAG_A#B: I<(outs rc:$nexttaggedptr), (ins table32_op:$table, rc:$taggedptr, rc:$offset), - (outs), (ins table32_op:$table), +defm MEMORY_ADDNEXTTAG_A#B: I<(outs rc:$nexttaggedptr), (ins i32imm:$tableidx, rc:$taggedptr, rc:$offset), + (outs), (ins i32imm:$tableidx), [(set rc:$nexttaggedptr, - (int_wasm_memory_addnexttag (WebAssemblyWrapper tglobaladdr:$table), rc:$taggedptr, rc:$offset))], - "memory.addnexttag\t$nexttaggedptr, $table, $taggedptr, $offset", - "memory.addnexttag\t$table", + (int_wasm_memory_addnexttag (i32 imm:$tableidx), rc:$taggedptr, rc:$offset))], + "memory.addnexttag\t$nexttaggedptr, $tableidx, $taggedptr, $offset", + "memory.addnexttag\t$tableidx", 0xfc2c>; } From b0da50a7cfe0fc707678e5550954b848850f0ae6 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 7 Jan 2024 14:29:38 -0500 Subject: [PATCH 071/111] fix wasmstacktagging compilation --- .../Target/WebAssembly/WebAssemblyStackTagging.cpp | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index abd8b769a7ae3..26509a76f649b 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -63,7 +63,7 @@ void WebAssemblyStackTagging::untagAlloca(AllocaInst *AI, Type *ArgOp0Type) { IRBuilder<> IRB(InsertBefore); - IRB.CreateCall(StoreTagDecl, {AI, IRB.getInt32(0), ConstantInt::get(ArgOp0Type, Size)}); + IRB.CreateCall(StoreTagDecl, {IRB.getInt32(0), AI, ConstantInt::get(ArgOp0Type, Size)}); } bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { @@ -110,7 +110,6 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { DeleteLI = std::make_unique(*DT); LI = DeleteLI.get(); } - for (auto &I : SInfo.AllocasToInstrument) { memtag::AllocaInfo &Info = I.second; TrackingVH OldAI = Info.AI; @@ -120,9 +119,9 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { Type *Int32Type = IRB.getInt32Ty(); Type *Int64Type = IRB.getInt64Ty(); Function *RandomStoreTagDecl = Intrinsic::getDeclaration( - F->getParent(), Intrinsic::wasm_memory_randomstoretag, {Int32Type, Int64Type}); + F->getParent(), Intrinsic::wasm_memory_randomstoretag, {Int64Type}); Function *StoreTagDecl = Intrinsic::getDeclaration( - F->getParent(), Intrinsic::wasm_memory_storetag, {Int32Type, Int64Type}); + F->getParent(), Intrinsic::wasm_memory_storetag, {Int64Type}); // Calls to functions that may return twice (e.g. setjmp) confuse the // postdominator analysis, and will leave us to keep memory tagged after @@ -139,7 +138,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { cast(Start->getArgOperand(0))->getZExtValue(); Size = alignTo(Size, kTagGranuleSize); Instruction *RandomStoreTagCall = IRB.CreateCall( - RandomStoreTagDecl, {Info.AI, ConstantInt::get(Int32Type, 0), ConstantInt::get(Int64Type, Size)}); + RandomStoreTagDecl, {ConstantInt::get(Int32Type, 0), Info.AI, ConstantInt::get(Int64Type, Size)}); if (Info.AI->hasName()) RandomStoreTagCall->setName(Info.AI->getName() + ".tag"); Info.AI->replaceAllUsesWith(RandomStoreTagCall); @@ -157,7 +156,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { } else { uint64_t Size = *Info.AI->getAllocationSize(*DL); IRB.CreateCall(RandomStoreTagDecl, - {AI, ConstantInt::get(Int32Type, 0), ConstantInt::get(Int64Type, Size)}); + {ConstantInt::get(Int32Type, 0), AI, ConstantInt::get(Int64Type, Size)}); for (auto *RI : SInfo.RetVec) { untagAlloca(AI, RI, Size, StoreTagDecl, Int64Type); } From 4547d87b88b83ee2fc9c27b4f5fd26818665e308 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 7 Jan 2024 15:09:06 -0500 Subject: [PATCH 072/111] naive fix to see what's going on with wasm stack tagging --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 26509a76f649b..f33349b54eb21 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -155,8 +155,12 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { } } else { uint64_t Size = *Info.AI->getAllocationSize(*DL); - IRB.CreateCall(RandomStoreTagDecl, + Instruction *RandomStoreTagCall = IRB.CreateCall(RandomStoreTagDecl, {ConstantInt::get(Int32Type, 0), AI, ConstantInt::get(Int64Type, Size)}); + if (Info.AI->hasName()) + RandomStoreTagCall->setName(Info.AI->getName() + ".tag"); + Info.AI->replaceAllUsesWith(RandomStoreTagCall); + RandomStoreTagCall->setOperand(0, Info.AI); for (auto *RI : SInfo.RetVec) { untagAlloca(AI, RI, Size, StoreTagDecl, Int64Type); } @@ -167,6 +171,9 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { for (auto *II : Info.LifetimeEnd) II->eraseFromParent(); } + // Fixup debug intrinsics to point to the new alloca. + for (auto *DVI : Info.DbgVariableIntrinsics) + DVI->replaceVariableLocationOp(OldAI, Info.AI); } return true; } From da1df72f5435035304d2fb701d5463df09a919b1 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 7 Jan 2024 15:18:43 -0500 Subject: [PATCH 073/111] fix parameter indexc --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index f33349b54eb21..c3fed29029dca 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -142,7 +142,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { if (Info.AI->hasName()) RandomStoreTagCall->setName(Info.AI->getName() + ".tag"); Info.AI->replaceAllUsesWith(RandomStoreTagCall); - RandomStoreTagCall->setOperand(0, Info.AI); + RandomStoreTagCall->setOperand(1, Info.AI); auto TagEnd = [&](Instruction *Node) { untagAlloca(AI, Node, Size, StoreTagDecl, Int64Type); @@ -160,7 +160,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { if (Info.AI->hasName()) RandomStoreTagCall->setName(Info.AI->getName() + ".tag"); Info.AI->replaceAllUsesWith(RandomStoreTagCall); - RandomStoreTagCall->setOperand(0, Info.AI); + RandomStoreTagCall->setOperand(1, Info.AI); for (auto *RI : SInfo.RetVec) { untagAlloca(AI, RI, Size, StoreTagDecl, Int64Type); } From 03e689da08f8434c27a57e9d1d43e2ede4c2b131 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 12 Jan 2024 18:04:53 -0500 Subject: [PATCH 074/111] Add mayload and maystore to memtag instructions --- llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 10 +++++----- llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td | 10 ++++++++++ 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index b188abf3008c8..01495bd108c9f 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -346,7 +346,7 @@ def int_wasm_tls_base : //===----------------------------------------------------------------------===// def int_wasm_memory_randomtag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.randomtag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem, IntrHasSideEffects], "llvm.wasm.memory.randomtag">; def int_wasm_memory_copytag : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.copytag">; @@ -370,16 +370,16 @@ def int_wasm_memory_storez1tag : DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storez1tag">; def int_wasm_memory_randomstoretag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoretag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects], "llvm.wasm.memory.randomstoretag">; def int_wasm_memory_randomstoreztag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstoreztag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects], "llvm.wasm.memory.randomstoreztag">; def int_wasm_memory_randomstore1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstore1tag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects], "llvm.wasm.memory.randomstore1tag">; def int_wasm_memory_randomstorez1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.randomstorez1tag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects], "llvm.wasm.memory.randomstorez1tag">; def int_wasm_memory_addnexttag : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memory.addnexttag">; diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 63cfb5167cace..9d774546b60ed 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -13,6 +13,7 @@ multiclass MemoryTaggingOps { +let hasSideEffects = 1 in defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -37,6 +38,7 @@ defm MEMORY_SUBTAG_A#B: I<(outs rc:$diff), (ins i32imm:$tableidx, rc:$minuendptr "memory.subtag\t$tableidx", 0xfc22>; +let mayLoad = 1 in defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins i32imm:$tableidx, rc:$src), (outs), (ins i32imm:$tableidx), [(set rc:$taggedptr, @@ -45,6 +47,7 @@ defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins i32imm:$tableidx, rc:$src) "memory.loadtag\t$tableidx", 0xfc23>; +let mayLoad = 1, mayStore = 1 in defm MEMORY_STORETAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(int_wasm_memory_storetag (i32 imm:$tableidx), rc:$src, rc:$b16)], @@ -52,6 +55,7 @@ defm MEMORY_STORETAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), "memory.storetag\t$tableidx", 0xfc24>; +let mayLoad = 1, mayStore = 1 in defm MEMORY_STOREZTAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(int_wasm_memory_storeztag (i32 imm:$tableidx), rc:$src, rc:$b16)], @@ -59,6 +63,7 @@ defm MEMORY_STOREZTAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), "memory.storeztag\t$tableidx", 0xfc25>; +let mayLoad = 1, mayStore = 1 in defm MEMORY_STORE1TAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(int_wasm_memory_store1tag (i32 imm:$tableidx), rc:$src, rc:$b16)], @@ -66,6 +71,7 @@ defm MEMORY_STORE1TAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), "memory.store1tag\t$tableidx", 0xfc26>; +let mayLoad = 1, mayStore = 1 in defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(int_wasm_memory_storez1tag (i32 imm:$tableidx), rc:$src, rc:$b16)], @@ -73,6 +79,7 @@ defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), "memory.storez1tag\t$tableidx", 0xfc27>; +let hasSideEffects = 1, mayLoad = 1, mayStore = 1 in defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -81,6 +88,7 @@ defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src "memory.randomstoretag\t$tableidx", 0xfc28>; +let hasSideEffects = 1, mayLoad = 1, mayStore = 1 in defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -89,6 +97,7 @@ defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$sr "memory.randomstoreztag\t$tableidx", 0xfc29>; +let hasSideEffects = 1, mayLoad = 1, mayStore = 1 in defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -97,6 +106,7 @@ defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$sr "memory.randomstore1tag\t$tableidx", 0xfc2a>; +let hasSideEffects = 1, mayLoad = 1, mayStore = 1 in defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(set rc:$dst, From 7b1671a6ff9b7d90ff04ac4fa21c8bbfd40d8c81 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 13 Jan 2024 18:26:53 -0500 Subject: [PATCH 075/111] Add hinttag memtag instructions for wasm memtag The reason is that ARM MTE allows to operate the tag part, it is very difficult to emulate the behavior when the architecture changes. I do not want the users to assume the size of memtag because maybe other architectures will use 8 bits instead of 4 bits for memtag in the future. However, I find that it is mainly used for tagging stack to avoid repeatly generating random numbers. This hint can be very useful since the VM can just emit the hint idx modding the actual tagging size which can work --- .../clang/Basic/BuiltinsWebAssembly.def | 14 +++-- clang/lib/CodeGen/CGBuiltin.cpp | 49 +++++++++++++-- llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 33 +++++++--- .../WebAssembly/WebAssemblyInstrMemtag.td | 63 +++++++++++++++---- 4 files changed, 127 insertions(+), 32 deletions(-) diff --git a/clang/include/clang/Basic/BuiltinsWebAssembly.def b/clang/include/clang/Basic/BuiltinsWebAssembly.def index 4172ba87c1323..c29a76d0f2126 100644 --- a/clang/include/clang/Basic/BuiltinsWebAssembly.def +++ b/clang/include/clang/Basic/BuiltinsWebAssembly.def @@ -34,11 +34,15 @@ BUILTIN(__builtin_wasm_memory_storetag, "vIiv*z", "n") BUILTIN(__builtin_wasm_memory_storeztag, "vIiv*z", "n") BUILTIN(__builtin_wasm_memory_store1tag, "vIiv*z", "n") BUILTIN(__builtin_wasm_memory_storez1tag, "vIiv*z", "n") -BUILTIN(__builtin_wasm_memory_randomstoretag, "vIi*v*z", "n") -BUILTIN(__builtin_wasm_memory_randomstoreztag, "vIi*v*z", "n") -BUILTIN(__builtin_wasm_memory_randomstore1tag, "vIi*v*z", "n") -BUILTIN(__builtin_wasm_memory_randomstorez1tag, "vIi*v*z", "n") -BUILTIN(__builtin_wasm_memory_addnexttag, "YIiv*z", "n") +BUILTIN(__builtin_wasm_memory_randomstoretag, "v*Iiv*z", "n") +BUILTIN(__builtin_wasm_memory_randomstoreztag, "v*Iiv*z", "n") +BUILTIN(__builtin_wasm_memory_randomstore1tag, "v*Iiv*z", "n") +BUILTIN(__builtin_wasm_memory_randomstorez1tag, "v*Iiv*z", "n") +BUILTIN(__builtin_wasm_memory_hinttag, "v*Iiv*v*z", "n") +BUILTIN(__builtin_wasm_memory_hintstoretag, "v*Iiv*zv*z", "n") +BUILTIN(__builtin_wasm_memory_hintstoreztag, "v*Iiv*zv*z", "n") +BUILTIN(__builtin_wasm_memory_hintstore1tag, "v*Iiv*zv*z", "n") +BUILTIN(__builtin_wasm_memory_hintstorez1tag, "v*Iiv*zv*z", "n") // Thread-local storage TARGET_BUILTIN(__builtin_wasm_tls_size, "z", "nc", "bulk-memory") diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 2f82c7c9ff35b..7121d8426ed76 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -20732,12 +20732,53 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstorez1tag, B16->getType()); return Builder.CreateCall(Callee, {Index, Ptr, B16}); } - case WebAssembly::BI__builtin_wasm_memory_addnexttag: { + case WebAssembly::BI__builtin_wasm_memory_hinttag: { Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); - Value *PtrOffset = EmitScalarExpr(E->getArg(2)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_addnexttag, PtrOffset->getType()); - return Builder.CreateCall(Callee, {Index, Ptr, PtrOffset}); + Value *HintPtr = EmitScalarExpr(E->getArg(2)); + Value *HintIdx = EmitScalarExpr(E->getArg(3)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_hinttag, HintIdx->getType()); + return Builder.CreateCall(Callee, {Index, Ptr, HintPtr, HintIdx}); + } + case WebAssembly::BI__builtin_wasm_memory_hintstoretag: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); + Value *HintPtr = EmitScalarExpr(E->getArg(3)); + Value *HintIdx = EmitScalarExpr(E->getArg(4)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_hintstoretag, + {B16->getType(), HintIdx->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, B16, HintPtr, HintIdx}); + } + case WebAssembly::BI__builtin_wasm_memory_hintstoreztag: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); + Value *HintPtr = EmitScalarExpr(E->getArg(3)); + Value *HintIdx = EmitScalarExpr(E->getArg(4)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_hintstoreztag, + {B16->getType(), HintIdx->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, B16, HintPtr, HintIdx}); + } + case WebAssembly::BI__builtin_wasm_memory_hintstore1tag: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); + Value *HintPtr = EmitScalarExpr(E->getArg(3)); + Value *HintIdx = EmitScalarExpr(E->getArg(4)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_hintstore1tag, + {B16->getType(), HintIdx->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, B16, HintPtr, HintIdx}); + } + case WebAssembly::BI__builtin_wasm_memory_hintstorez1tag: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); + Value *HintPtr = EmitScalarExpr(E->getArg(3)); + Value *HintIdx = EmitScalarExpr(E->getArg(4)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_hintstorez1tag, + {B16->getType(), HintIdx->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, B16, HintPtr, HintIdx}); } default: return nullptr; diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index 01495bd108c9f..88dde1c58d330 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -358,30 +358,43 @@ def int_wasm_memory_loadtag : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrReadMem], "llvm.wasm.memory.loadtag">; def int_wasm_memory_storetag : - DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storetag">; + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.storetag">; def int_wasm_memory_storeztag : - DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storeztag">; + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.storeztag">; def int_wasm_memory_store1tag : - DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.store1tag">; + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.store1tag">; def int_wasm_memory_storez1tag : - DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [], "llvm.wasm.memory.storez1tag">; + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.storez1tag">; def int_wasm_memory_randomstoretag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects], "llvm.wasm.memory.randomstoretag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.randomstoretag">; def int_wasm_memory_randomstoreztag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects], "llvm.wasm.memory.randomstoreztag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.randomstoreztag">; def int_wasm_memory_randomstore1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects], "llvm.wasm.memory.randomstore1tag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.randomstore1tag">; def int_wasm_memory_randomstorez1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects], "llvm.wasm.memory.randomstorez1tag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.randomstorez1tag">; + +def int_wasm_memory_hinttag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem, IntrHasSideEffects], "llvm.wasm.memory.hinttag">; + +def int_wasm_memory_hintstoretag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.hintstoretag">; + +def int_wasm_memory_hintstoreztag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.hintstoreztag">; + +def int_wasm_memory_hintstore1tag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.hintstore1tag">; + +def int_wasm_memory_hintstorez1tag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.hintstorez1tag">; -def int_wasm_memory_addnexttag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memory.addnexttag">; } // TargetPrefix = "wasm" diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 9d774546b60ed..9a0018f159a5d 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -47,7 +47,7 @@ defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins i32imm:$tableidx, rc:$src) "memory.loadtag\t$tableidx", 0xfc23>; -let mayLoad = 1, mayStore = 1 in +let mayStore = 1 in defm MEMORY_STORETAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(int_wasm_memory_storetag (i32 imm:$tableidx), rc:$src, rc:$b16)], @@ -55,7 +55,7 @@ defm MEMORY_STORETAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), "memory.storetag\t$tableidx", 0xfc24>; -let mayLoad = 1, mayStore = 1 in +let mayStore = 1 in defm MEMORY_STOREZTAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(int_wasm_memory_storeztag (i32 imm:$tableidx), rc:$src, rc:$b16)], @@ -63,7 +63,7 @@ defm MEMORY_STOREZTAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), "memory.storeztag\t$tableidx", 0xfc25>; -let mayLoad = 1, mayStore = 1 in +let mayStore = 1 in defm MEMORY_STORE1TAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(int_wasm_memory_store1tag (i32 imm:$tableidx), rc:$src, rc:$b16)], @@ -71,7 +71,7 @@ defm MEMORY_STORE1TAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), "memory.store1tag\t$tableidx", 0xfc26>; -let mayLoad = 1, mayStore = 1 in +let mayStore = 1 in defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(int_wasm_memory_storez1tag (i32 imm:$tableidx), rc:$src, rc:$b16)], @@ -79,7 +79,7 @@ defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), "memory.storez1tag\t$tableidx", 0xfc27>; -let hasSideEffects = 1, mayLoad = 1, mayStore = 1 in +let hasSideEffects = 1, mayStore = 1 in defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -88,7 +88,7 @@ defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src "memory.randomstoretag\t$tableidx", 0xfc28>; -let hasSideEffects = 1, mayLoad = 1, mayStore = 1 in +let hasSideEffects = 1, mayStore = 1 in defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -97,7 +97,7 @@ defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$sr "memory.randomstoreztag\t$tableidx", 0xfc29>; -let hasSideEffects = 1, mayLoad = 1, mayStore = 1 in +let hasSideEffects = 1, mayStore = 1 in defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -106,7 +106,7 @@ defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$sr "memory.randomstore1tag\t$tableidx", 0xfc2a>; -let hasSideEffects = 1, mayLoad = 1, mayStore = 1 in +let hasSideEffects = 1, mayStore = 1 in defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -115,14 +115,51 @@ defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$s "memory.randomstorez1tag\t$tableidx", 0xfc2b>; -defm MEMORY_ADDNEXTTAG_A#B: I<(outs rc:$nexttaggedptr), (ins i32imm:$tableidx, rc:$taggedptr, rc:$offset), +let hasSideEffects = 1 in +defm MEMORY_HINTTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$hintaddr, rc:$index), (outs), (ins i32imm:$tableidx), - [(set rc:$nexttaggedptr, - (int_wasm_memory_addnexttag (i32 imm:$tableidx), rc:$taggedptr, rc:$offset))], - "memory.addnexttag\t$nexttaggedptr, $tableidx, $taggedptr, $offset", - "memory.addnexttag\t$tableidx", + [(set rc:$dst, + (int_wasm_memory_hinttag (i32 imm:$tableidx), rc:$src, rc:$hintaddr, rc:$index))], + "memory.hinttag\t$dst, $tableidx, $src, $hintaddr, $index", + "memory.hinttag\t$tableidx", 0xfc2c>; +let hasSideEffects = 1, mayStore = 1 in +defm MEMORY_HINTSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memory_hintstoretag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$hintaddr, rc:$index))], + "memory.hintstoretag\t$dst, $tableidx, $src, $b16, $hintaddr, $index", + "memory.hintstoretag\t$tableidx", + 0xfc2d>; + +let hasSideEffects = 1, mayStore = 1 in +defm MEMORY_HINTSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memory_hintstoreztag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$hintaddr, rc:$index))], + "memory.hintstoreztag\t$dst, $tableidx, $src, $b16, $hintaddr, $index", + "memory.hintstoreztag\t$tableidx", + 0xfc2e>; + +let hasSideEffects = 1, mayStore = 1 in +defm MEMORY_HINTSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memory_hintstore1tag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$hintaddr, rc:$index))], + "memory.hintstore1tag\t$dst, $tableidx, $src, $b16, $hintaddr, $index", + "memory.hintstore1tag\t$tableidx", + 0xfc2f>; + +let hasSideEffects = 1, mayStore = 1 in +defm MEMORY_HINTSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memory_hintstorez1tag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$hintaddr, rc:$index))], + "memory.hintstorez1tag\t$dst, $tableidx, $src, $b16, $hintaddr, $index", + "memory.hintstorez1tag\t$tableidx", + 0xfc30>; + } defm : MemoryTaggingOps; From 24c6b2fa38748758c56c2c4158898d24314255f8 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 13 Jan 2024 20:43:16 -0500 Subject: [PATCH 076/111] Add addtag family instruction for memtag I forgot the offset can still be useful by avoiding add Fix --- .../clang/Basic/BuiltinsWebAssembly.def | 5 ++ clang/lib/CodeGen/CGBuiltin.cpp | 49 +++++++++++++++++++ llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 14 ++++++ .../WebAssembly/WebAssemblyInstrMemtag.td | 45 +++++++++++++++++ 4 files changed, 113 insertions(+) diff --git a/clang/include/clang/Basic/BuiltinsWebAssembly.def b/clang/include/clang/Basic/BuiltinsWebAssembly.def index c29a76d0f2126..5ece16813fd75 100644 --- a/clang/include/clang/Basic/BuiltinsWebAssembly.def +++ b/clang/include/clang/Basic/BuiltinsWebAssembly.def @@ -43,6 +43,11 @@ BUILTIN(__builtin_wasm_memory_hintstoretag, "v*Iiv*zv*z", "n") BUILTIN(__builtin_wasm_memory_hintstoreztag, "v*Iiv*zv*z", "n") BUILTIN(__builtin_wasm_memory_hintstore1tag, "v*Iiv*zv*z", "n") BUILTIN(__builtin_wasm_memory_hintstorez1tag, "v*Iiv*zv*z", "n") +BUILTIN(__builtin_wasm_memory_addtag, "v*Iiv*Yz", "n") +BUILTIN(__builtin_wasm_memory_addstoretag, "v*Iiv*zYz", "n") +BUILTIN(__builtin_wasm_memory_addstoreztag, "v*Iiv*zYz", "n") +BUILTIN(__builtin_wasm_memory_addstore1tag, "v*Iiv*zYz", "n") +BUILTIN(__builtin_wasm_memory_addstorez1tag, "v*Iiv*zYz", "n") // Thread-local storage TARGET_BUILTIN(__builtin_wasm_tls_size, "z", "nc", "bulk-memory") diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 7121d8426ed76..81fcffd65d3df 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -20780,6 +20780,55 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, {B16->getType(), HintIdx->getType()}); return Builder.CreateCall(Callee, {Index, Ptr, B16, HintPtr, HintIdx}); } + case WebAssembly::BI__builtin_wasm_memory_addtag: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *Offset = EmitScalarExpr(E->getArg(2)); + Value *HintIdx = EmitScalarExpr(E->getArg(3)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_addtag, + {Offset->getType(), HintIdx->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, Offset, HintIdx}); + } + case WebAssembly::BI__builtin_wasm_memory_addstoretag: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); + Value *Offset = EmitScalarExpr(E->getArg(3)); + Value *HintIdx = EmitScalarExpr(E->getArg(4)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_hintstoretag, + {B16->getType(), Offset->getType(), HintIdx->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, B16, Offset, HintIdx}); + } + case WebAssembly::BI__builtin_wasm_memory_addstoreztag: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); + Value *Offset = EmitScalarExpr(E->getArg(3)); + Value *HintIdx = EmitScalarExpr(E->getArg(4)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_addstoreztag, + {B16->getType(), Offset->getType(), HintIdx->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, B16, Offset, HintIdx}); + } + case WebAssembly::BI__builtin_wasm_memory_addstore1tag: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); + Value *Offset = EmitScalarExpr(E->getArg(3)); + Value *HintIdx = EmitScalarExpr(E->getArg(4)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_addstore1tag, + {B16->getType(), Offset->getType(), HintIdx->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, B16, Offset, HintIdx}); + } + case WebAssembly::BI__builtin_wasm_memory_addstorez1tag: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); + Value *Offset = EmitScalarExpr(E->getArg(3)); + Value *HintIdx = EmitScalarExpr(E->getArg(4)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_addstorez1tag, + {B16->getType(), Offset->getType(), HintIdx->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, B16, Offset, HintIdx}); + } default: return nullptr; } diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index 88dde1c58d330..21499bfe575de 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -396,5 +396,19 @@ def int_wasm_memory_hintstore1tag : def int_wasm_memory_hintstorez1tag : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.hintstorez1tag">; +def int_wasm_memory_addtag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrNoMem, IntrHasSideEffects], "llvm.wasm.memory.addtag">; + +def int_wasm_memory_addstoretag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.addstoretag">; + +def int_wasm_memory_addstoreztag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.addstoreztag">; + +def int_wasm_memory_addstore1tag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.addstore1tag">; + +def int_wasm_memory_addstorez1tag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.addstorez1tag">; } // TargetPrefix = "wasm" diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 9a0018f159a5d..ec9a80412e95c 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -160,6 +160,51 @@ defm MEMORY_HINTSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src "memory.hintstorez1tag\t$tableidx", 0xfc30>; +let hasSideEffects = 1 in +defm MEMORY_ADDTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$addoffset, rc:$index), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memory_addtag (i32 imm:$tableidx), rc:$src, rc:$addoffset, rc:$index))], + "memory.addtag\t$dst, $tableidx, $src, $addoffset, $index", + "memory.addtag\t$tableidx", + 0xfc31>; + +let hasSideEffects = 1, mayStore = 1 in +defm MEMORY_ADDSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addoffset, rc:$index), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memory_addstoretag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$addoffset, rc:$index))], + "memory.addstoretag\t$dst, $tableidx, $src, $b16, $addoffset, $index", + "memory.addstoretag\t$tableidx", + 0xfc32>; + +let hasSideEffects = 1, mayStore = 1 in +defm MEMORY_ADDSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addoffset, rc:$index), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memory_addstoreztag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$addoffset, rc:$index))], + "memory.addstoreztag\t$dst, $tableidx, $src, $b16, $addoffset, $index", + "memory.addstoreztag\t$tableidx", + 0xfc33>; + +let hasSideEffects = 1, mayStore = 1 in +defm MEMORY_ADDSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addoffset, rc:$index), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memory_addstore1tag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$addoffset, rc:$index))], + "memory.addstore1tag\t$dst, $tableidx, $src, $b16, $addoffset, $index", + "memory.addstore1tag\t$tableidx", + 0xfc34>; + +let hasSideEffects = 1, mayStore = 1 in +defm MEMORY_ADDSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addoffset, rc:$index), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memory_addstorez1tag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$addoffset, rc:$index))], + "memory.addstorez1tag\t$dst, $tableidx, $src, $b16, $addoffset, $index", + "memory.addstorez1tag\t$tableidx", + 0xfc35>; + } defm : MemoryTaggingOps; From 2fe6dce98c602dc65ecd347d80b9373ac6ea47d2 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 13 Jan 2024 20:48:08 -0500 Subject: [PATCH 077/111] Remove side effect from hintstoretag and addstoretag They can provide deterministic result. so no need to add side effects --- llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 20 +++++++++---------- .../WebAssembly/WebAssemblyInstrMemtag.td | 18 ++++++++--------- 2 files changed, 18 insertions(+), 20 deletions(-) diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index 21499bfe575de..361303aaaaf7d 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -382,33 +382,33 @@ def int_wasm_memory_randomstorez1tag : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.randomstorez1tag">; def int_wasm_memory_hinttag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem, IntrHasSideEffects], "llvm.wasm.memory.hinttag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memory.hinttag">; def int_wasm_memory_hintstoretag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.hintstoretag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.hintstoretag">; def int_wasm_memory_hintstoreztag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.hintstoreztag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.hintstoreztag">; def int_wasm_memory_hintstore1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.hintstore1tag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.hintstore1tag">; def int_wasm_memory_hintstorez1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.hintstorez1tag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.hintstorez1tag">; def int_wasm_memory_addtag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrNoMem, IntrHasSideEffects], "llvm.wasm.memory.addtag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memory.addtag">; def int_wasm_memory_addstoretag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.addstoretag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.addstoretag">; def int_wasm_memory_addstoreztag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.addstoreztag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.addstoreztag">; def int_wasm_memory_addstore1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.addstore1tag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.addstore1tag">; def int_wasm_memory_addstorez1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.addstorez1tag">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.addstorez1tag">; } // TargetPrefix = "wasm" diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index ec9a80412e95c..03ded52ef3270 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -115,7 +115,6 @@ defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$s "memory.randomstorez1tag\t$tableidx", 0xfc2b>; -let hasSideEffects = 1 in defm MEMORY_HINTTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$hintaddr, rc:$index), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -124,7 +123,7 @@ defm MEMORY_HINTTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$h "memory.hinttag\t$tableidx", 0xfc2c>; -let hasSideEffects = 1, mayStore = 1 in +let mayStore = 1 in defm MEMORY_HINTSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -133,7 +132,7 @@ defm MEMORY_HINTSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, "memory.hintstoretag\t$tableidx", 0xfc2d>; -let hasSideEffects = 1, mayStore = 1 in +let mayStore = 1 in defm MEMORY_HINTSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -142,7 +141,7 @@ defm MEMORY_HINTSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, "memory.hintstoreztag\t$tableidx", 0xfc2e>; -let hasSideEffects = 1, mayStore = 1 in +let mayStore = 1 in defm MEMORY_HINTSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -151,7 +150,7 @@ defm MEMORY_HINTSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, "memory.hintstore1tag\t$tableidx", 0xfc2f>; -let hasSideEffects = 1, mayStore = 1 in +let mayStore = 1 in defm MEMORY_HINTSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -160,7 +159,6 @@ defm MEMORY_HINTSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src "memory.hintstorez1tag\t$tableidx", 0xfc30>; -let hasSideEffects = 1 in defm MEMORY_ADDTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$addoffset, rc:$index), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -169,7 +167,7 @@ defm MEMORY_ADDTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$ad "memory.addtag\t$tableidx", 0xfc31>; -let hasSideEffects = 1, mayStore = 1 in +let mayStore = 1 in defm MEMORY_ADDSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addoffset, rc:$index), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -178,7 +176,7 @@ defm MEMORY_ADDSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, r "memory.addstoretag\t$tableidx", 0xfc32>; -let hasSideEffects = 1, mayStore = 1 in +let mayStore = 1 in defm MEMORY_ADDSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addoffset, rc:$index), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -187,7 +185,7 @@ defm MEMORY_ADDSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, "memory.addstoreztag\t$tableidx", 0xfc33>; -let hasSideEffects = 1, mayStore = 1 in +let mayStore = 1 in defm MEMORY_ADDSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addoffset, rc:$index), (outs), (ins i32imm:$tableidx), [(set rc:$dst, @@ -196,7 +194,7 @@ defm MEMORY_ADDSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, "memory.addstore1tag\t$tableidx", 0xfc34>; -let hasSideEffects = 1, mayStore = 1 in +let mayStore = 1 in defm MEMORY_ADDSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addoffset, rc:$index), (outs), (ins i32imm:$tableidx), [(set rc:$dst, From cf50e0d2634516e88ca3d3b17a1ab53473ea0f34 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 14 Jan 2024 18:37:28 -0500 Subject: [PATCH 078/111] backup code for handling lifetime --- .../WebAssembly/WebAssemblyStackTagging.cpp | 79 ++++++++++++++----- 1 file changed, 59 insertions(+), 20 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index c3fed29029dca..d0bd5183e0050 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -9,6 +9,7 @@ #include "llvm/Analysis/AliasAnalysis.h" #include "llvm/Analysis/PostDominators.h" #include "llvm/Analysis/StackSafetyAnalysis.h" +#include "llvm/IR/Constants.h" #include "llvm/IR/Function.h" #include "llvm/IR/IRBuilder.h" #include "llvm/IR/InstIterator.h" @@ -37,6 +38,10 @@ struct WebAssemblyStackTagging : public FunctionPass { void untagAlloca(AllocaInst *AI, Instruction *InsertBefore, uint64_t Size, Function *StoreTagDecl, Type *ArgOp0Type); + Instruction *insertBaseTaggedPointer( + const MapVector &Allocas, + const DominatorTree *DT); + bool runOnFunction(Function &) override; private: @@ -63,7 +68,34 @@ void WebAssemblyStackTagging::untagAlloca(AllocaInst *AI, Type *ArgOp0Type) { IRBuilder<> IRB(InsertBefore); - IRB.CreateCall(StoreTagDecl, {IRB.getInt32(0), AI, ConstantInt::get(ArgOp0Type, Size)}); + IRB.CreateCall(StoreTagDecl, + {IRB.getInt32(0), AI, ConstantInt::get(ArgOp0Type, Size)}); +} + +Instruction *WebAssemblyStackTagging::insertBaseTaggedPointer( + const MapVector &AllocasToInstrument, + const DominatorTree *DT) { + BasicBlock *PrologueBB = nullptr; + // Try sinking IRG as deep as possible to avoid hurting shrink wrap. + for (auto &I : AllocasToInstrument) { + const memtag::AllocaInfo &Info = I.second; + AllocaInst *AI = Info.AI; + if (!PrologueBB) { + PrologueBB = AI->getParent(); + continue; + } + PrologueBB = DT->findNearestCommonDominator(PrologueBB, AI->getParent()); + } + assert(PrologueBB); + + IRBuilder<> IRB(&PrologueBB->front()); + Function *RdTag = Intrinsic::getDeclaration(F->getParent(), + Intrinsic::wasm_memory_randomtag); + Instruction *Base = + IRB.CreateCall(RdTag, {IRB.getInt32(0), + ::llvm::ConstantPointerNull::get(IRB.getPtrTy())}); + Base->setName("basetag"); + return Base; } bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { @@ -72,11 +104,8 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { F = &Fn; DL = &Fn.getParent()->getDataLayout(); -#if 1 -// Unsure of the purpose of the SSI analysis in this context. -// Please place it under further review. + SSI = &getAnalysis().getResult(); -#endif memtag::StackInfoBuilder SIB(SSI); for (Instruction &I : instructions(F)) SIB.visit(I); @@ -110,18 +139,33 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { DeleteLI = std::make_unique(*DT); LI = DeleteLI.get(); } - for (auto &I : SInfo.AllocasToInstrument) { + auto &AllocasToInstrument = SInfo.AllocasToInstrument; + if (AllocasToInstrument.empty()) { + return true; + } + Instruction *Base = insertBaseTaggedPointer(AllocasToInstrument, DT); + uint64_t NextTag = 0; + for (auto &I : AllocasToInstrument) { memtag::AllocaInfo &Info = I.second; TrackingVH OldAI = Info.AI; memtag::alignAndPadAlloca(Info, kTagGranuleSize); + uint64_t Tag = NextTag; + ++NextTag; AllocaInst *AI = Info.AI; IRBuilder<> IRB(Info.AI->getNextNode()); Type *Int32Type = IRB.getInt32Ty(); Type *Int64Type = IRB.getInt64Ty(); - Function *RandomStoreTagDecl = Intrinsic::getDeclaration( - F->getParent(), Intrinsic::wasm_memory_randomstoretag, {Int64Type}); + Function *HintTagDecl = Intrinsic::getDeclaration( + F->getParent(), Intrinsic::wasm_memory_hinttag, {Int64Type}); Function *StoreTagDecl = Intrinsic::getDeclaration( F->getParent(), Intrinsic::wasm_memory_storetag, {Int64Type}); + Instruction *TagPCall = + IRB.CreateCall(HintTagDecl, {ConstantInt::get(Int32Type, 0), Info.AI, + Base, ConstantInt::get(Int64Type, Tag)}); + if (Info.AI->hasName()) + TagPCall->setName(Info.AI->getName() + ".tag"); + Info.AI->replaceAllUsesWith(TagPCall); + TagPCall->setOperand(1, Info.AI); // Calls to functions that may return twice (e.g. setjmp) confuse the // postdominator analysis, and will leave us to keep memory tagged after @@ -137,12 +181,10 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { uint64_t Size = cast(Start->getArgOperand(0))->getZExtValue(); Size = alignTo(Size, kTagGranuleSize); - Instruction *RandomStoreTagCall = IRB.CreateCall( - RandomStoreTagDecl, {ConstantInt::get(Int32Type, 0), Info.AI, ConstantInt::get(Int64Type, Size)}); - if (Info.AI->hasName()) - RandomStoreTagCall->setName(Info.AI->getName() + ".tag"); - Info.AI->replaceAllUsesWith(RandomStoreTagCall); - RandomStoreTagCall->setOperand(1, Info.AI); + + IRBuilder<> IRB2(Start->getNextNode()); + IRB2.CreateCall(StoreTagDecl, {ConstantInt::get(Int32Type, 0), TagPCall, + ConstantInt::get(Int64Type, Size)}); auto TagEnd = [&](Instruction *Node) { untagAlloca(AI, Node, Size, StoreTagDecl, Int64Type); @@ -155,12 +197,9 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { } } else { uint64_t Size = *Info.AI->getAllocationSize(*DL); - Instruction *RandomStoreTagCall = IRB.CreateCall(RandomStoreTagDecl, - {ConstantInt::get(Int32Type, 0), AI, ConstantInt::get(Int64Type, Size)}); - if (Info.AI->hasName()) - RandomStoreTagCall->setName(Info.AI->getName() + ".tag"); - Info.AI->replaceAllUsesWith(RandomStoreTagCall); - RandomStoreTagCall->setOperand(1, Info.AI); + Value *Ptr = IRB.CreatePointerCast(TagPCall, IRB.getPtrTy()); + IRB.CreateCall(StoreTagDecl, {ConstantInt::get(Int32Type, 0), Ptr, + ConstantInt::get(Int64Type, Size)}); for (auto *RI : SInfo.RetVec) { untagAlloca(AI, RI, Size, StoreTagDecl, Int64Type); } From 6c708a2a433b63eb4ac730e806ddffafc8ca8fb8 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 14 Jan 2024 19:05:51 -0500 Subject: [PATCH 079/111] special path for stnon standard life time tagging --- .../WebAssembly/WebAssemblyStackTagging.cpp | 32 +++++++++++-------- 1 file changed, 19 insertions(+), 13 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index d0bd5183e0050..68defe102eb92 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -155,18 +155,8 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { IRBuilder<> IRB(Info.AI->getNextNode()); Type *Int32Type = IRB.getInt32Ty(); Type *Int64Type = IRB.getInt64Ty(); - Function *HintTagDecl = Intrinsic::getDeclaration( - F->getParent(), Intrinsic::wasm_memory_hinttag, {Int64Type}); Function *StoreTagDecl = Intrinsic::getDeclaration( F->getParent(), Intrinsic::wasm_memory_storetag, {Int64Type}); - Instruction *TagPCall = - IRB.CreateCall(HintTagDecl, {ConstantInt::get(Int32Type, 0), Info.AI, - Base, ConstantInt::get(Int64Type, Tag)}); - if (Info.AI->hasName()) - TagPCall->setName(Info.AI->getName() + ".tag"); - Info.AI->replaceAllUsesWith(TagPCall); - TagPCall->setOperand(1, Info.AI); - // Calls to functions that may return twice (e.g. setjmp) confuse the // postdominator analysis, and will leave us to keep memory tagged after // function return. Work around this by always untagging at every return @@ -177,6 +167,15 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { 3) && !SInfo.CallsReturnTwice; if (StandardLifetime) { + auto *HintTagDecl = Intrinsic::getDeclaration( + F->getParent(), Intrinsic::wasm_memory_hinttag, {Int64Type}); + auto *TagPCall = + IRB.CreateCall(HintTagDecl, {ConstantInt::get(Int32Type, 0), Info.AI, + Base, ConstantInt::get(Int64Type, Tag)}); + if (Info.AI->hasName()) + TagPCall->setName(Info.AI->getName() + ".tag"); + Info.AI->replaceAllUsesWith(TagPCall); + TagPCall->setOperand(1, Info.AI); IntrinsicInst *Start = Info.LifetimeStart[0]; uint64_t Size = cast(Start->getArgOperand(0))->getZExtValue(); @@ -197,9 +196,16 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { } } else { uint64_t Size = *Info.AI->getAllocationSize(*DL); - Value *Ptr = IRB.CreatePointerCast(TagPCall, IRB.getPtrTy()); - IRB.CreateCall(StoreTagDecl, {ConstantInt::get(Int32Type, 0), Ptr, - ConstantInt::get(Int64Type, Size)}); + auto *HintStoreTagDecl = Intrinsic::getDeclaration( + F->getParent(), Intrinsic::wasm_memory_hintstoretag, {Int64Type}); + auto *TagPCall = IRB.CreateCall(HintStoreTagDecl, + {ConstantInt::get(Int32Type, 0), Info.AI, + ConstantInt::get(Int64Type, Size), Base, + ConstantInt::get(Int64Type, Tag)}); + if (Info.AI->hasName()) + TagPCall->setName(Info.AI->getName() + ".tag"); + Info.AI->replaceAllUsesWith(TagPCall); + TagPCall->setOperand(1, Info.AI); for (auto *RI : SInfo.RetVec) { untagAlloca(AI, RI, Size, StoreTagDecl, Int64Type); } From 07ab0a5be48d5e9e250a9473a478796b79694961 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 14 Jan 2024 19:21:01 -0500 Subject: [PATCH 080/111] Fixing all bugs i know in wasm memtag although the code does not feel optimal --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 68defe102eb92..019b70c64681e 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -197,7 +197,8 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { } else { uint64_t Size = *Info.AI->getAllocationSize(*DL); auto *HintStoreTagDecl = Intrinsic::getDeclaration( - F->getParent(), Intrinsic::wasm_memory_hintstoretag, {Int64Type}); + F->getParent(), Intrinsic::wasm_memory_hintstoretag, + {Int64Type, Int64Type}); auto *TagPCall = IRB.CreateCall(HintStoreTagDecl, {ConstantInt::get(Int32Type, 0), Info.AI, ConstantInt::get(Int64Type, Size), Base, From 2c0d203ec3188ed553a9ec1a830cf1e5b942e279 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 21 Jan 2024 18:41:15 -0500 Subject: [PATCH 081/111] use starts_with for global taggings --- llvm/lib/Target/WebAssembly/WebAssemblyGlobalsTagging.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyGlobalsTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyGlobalsTagging.cpp index d6b0061bc6061..01da537c91925 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyGlobalsTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyGlobalsTagging.cpp @@ -36,7 +36,7 @@ static bool shouldTagGlobal(GlobalVariable &G) { // For now, don't instrument constant data, as it'll be in .rodata anyway. It // may be worth instrumenting these in future to stop them from being used as // gadgets. - if (G.getName().startswith("llvm.") || G.isThreadLocal() || G.isConstant()) { + if (G.getName().starts_with("llvm.") || G.isThreadLocal() || G.isConstant()) { Meta.Memtag = false; G.setSanitizerMetadata(Meta); return false; From 8a2c93400a392df14ad92ceeaa8ac809c531a2c8 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 21 Jan 2024 20:20:31 -0500 Subject: [PATCH 082/111] revert changes to clang pseudo --- clang-tools-extra/pseudo/include/CMakeLists.txt | 8 -------- 1 file changed, 8 deletions(-) diff --git a/clang-tools-extra/pseudo/include/CMakeLists.txt b/clang-tools-extra/pseudo/include/CMakeLists.txt index 605f17dd4591a..77e08bf14e770 100644 --- a/clang-tools-extra/pseudo/include/CMakeLists.txt +++ b/clang-tools-extra/pseudo/include/CMakeLists.txt @@ -3,14 +3,6 @@ set(cxx_bnf ${CMAKE_CURRENT_SOURCE_DIR}/../lib/cxx/cxx.bnf) setup_host_tool(clang-pseudo-gen CLANG_PSEUDO_GEN pseudo_gen pseudo_gen_target) -if(NOT DEFINED CLANG_PSEUDO_GEN) - if(DEFINED LLVM_NATIVE_TOOL_DIR AND NOT LLVM_NATIVE_TOOL_DIR STREQUAL "") - set(CLANG_PSEUDO_GEN "${LLVM_NATIVE_TOOL_DIR}/clang_pseudo_gen") - else() - set(CLANG_PSEUDO_GEN "${pseudo_gen}") - endif() -endif() - # Generate inc files. set(cxx_symbols_inc ${CMAKE_CURRENT_BINARY_DIR}/CXXSymbols.inc) add_custom_command(OUTPUT ${cxx_symbols_inc} From 4c2e36ccffe26e55cc06ae5cd71a49104d47fe18 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 21 Jan 2024 20:37:03 -0500 Subject: [PATCH 083/111] revert changes --- clang-tools-extra/pseudo/include/CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/clang-tools-extra/pseudo/include/CMakeLists.txt b/clang-tools-extra/pseudo/include/CMakeLists.txt index 77e08bf14e770..2334cfa12e337 100644 --- a/clang-tools-extra/pseudo/include/CMakeLists.txt +++ b/clang-tools-extra/pseudo/include/CMakeLists.txt @@ -6,7 +6,7 @@ setup_host_tool(clang-pseudo-gen CLANG_PSEUDO_GEN pseudo_gen pseudo_gen_target) # Generate inc files. set(cxx_symbols_inc ${CMAKE_CURRENT_BINARY_DIR}/CXXSymbols.inc) add_custom_command(OUTPUT ${cxx_symbols_inc} - COMMAND "${CLANG_PSEUDO_GEN}" + COMMAND "${pseudo_gen}" --grammar ${cxx_bnf} --emit-symbol-list -o ${cxx_symbols_inc} @@ -16,7 +16,7 @@ add_custom_command(OUTPUT ${cxx_symbols_inc} set(cxx_bnf_inc ${CMAKE_CURRENT_BINARY_DIR}/CXXBNF.inc) add_custom_command(OUTPUT ${cxx_bnf_inc} - COMMAND "${CLANG_PSEUDO_GEN}" + COMMAND "${pseudo_gen}" --grammar ${cxx_bnf} --emit-grammar-content -o ${cxx_bnf_inc} From 7ced2f80f90fe4adf58f3927e52698fb5b0dfea0 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Tue, 30 Jan 2024 20:56:53 -0500 Subject: [PATCH 084/111] revert the change in triple.h --- llvm/include/llvm/TargetParser/Triple.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/include/llvm/TargetParser/Triple.h b/llvm/include/llvm/TargetParser/Triple.h index ae2b0ddc5e902..8845be080443a 100644 --- a/llvm/include/llvm/TargetParser/Triple.h +++ b/llvm/include/llvm/TargetParser/Triple.h @@ -958,7 +958,7 @@ class Triple { /// Note: Android API level 29 (10) introduced ELF TLS. bool hasDefaultEmulatedTLS() const { return (isAndroid() && isAndroidVersionLT(29)) || isOSOpenBSD() || - isOSCygMing() || isOHOSFamily(); + isWindowsCygwinEnvironment() || isOHOSFamily(); } /// True if the target supports both general-dynamic and TLSDESC, and TLSDESC From ce029453322ac41c801b8289e9f8ded4d89374a5 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 11 May 2024 16:46:31 -0400 Subject: [PATCH 085/111] fix merge issue from wasm sub target --- llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h | 4 ---- 1 file changed, 4 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h b/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h index 8aed2a7def48a..7515550455e47 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h +++ b/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h @@ -49,9 +49,6 @@ class WebAssemblySubtarget final : public WebAssemblyGenSubtargetInfo { bool HasMutableGlobals = false; bool HasNontrappingFPToInt = false; bool HasReferenceTypes = false; - bool HasExtendedConst = false; - bool HasMultiMemory = false; - bool HasHalfPrecision = false; bool HasMemtag = false; bool HasSignExt = false; bool HasTailCall = false; @@ -106,7 +103,6 @@ class WebAssemblySubtarget final : public WebAssemblyGenSubtargetInfo { bool hasMutableGlobals() const { return HasMutableGlobals; } bool hasNontrappingFPToInt() const { return HasNontrappingFPToInt; } bool hasReferenceTypes() const { return HasReferenceTypes; } - bool hasMultiMemory() const { return HasMultiMemory; } bool hasMemtag() const { return HasMemtag; } bool hasRelaxedSIMD() const { return SIMDLevel >= RelaxedSIMD; } bool hasSignExt() const { return HasSignExt; } From e20b3c0cfb9a7941dc4a788682f16d3d5d519e17 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 30 May 2024 13:04:23 -0400 Subject: [PATCH 086/111] Add experimental support for wasm32 wasm32 does not guarantee a very high probalistic of protection, but it is still useful as it can prevent 75% of issues --- clang/lib/Driver/ToolChains/CommonArgs.cpp | 3 ++- llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp index bdd01035e2444..53ba6e2a4cfc6 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.cpp +++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp @@ -1504,7 +1504,8 @@ bool tools::addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args, CmdArgs.push_back("--export-dynamic-symbol=__cfi_check"); if (SanArgs.hasMemTag()) { - if (TC.getTriple().getArch() == ::llvm::Triple::wasm64) + if (TC.getTriple().getArch() == ::llvm::Triple::wasm32 + || TC.getTriple().getArch() == ::llvm::Triple::wasm64) { } diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp index da6496aac09e8..27ba2e9d7351e 100644 --- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -767,7 +767,7 @@ void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) { bool supportMemtagGlobals = false; - if (arch == Triple::wasm64) { + if (arch == Triple::wasm32 || arch == Triple::wasm64) { supportMemtagGlobals = true; } else if (arch == Triple::aarch64 && T.isAndroid()) { @@ -777,7 +777,7 @@ void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) { if (!supportMemtagGlobals) OutContext.reportError(SMLoc(), "tagged symbols (-fsanitize=memtag-globals) are " - "only supported on AArch64 Android or Wasm64"); + "only supported on AArch64 Android or WebAssembly"); OutStreamer->emitSymbolAttribute(EmittedSym, MAI->getMemtagAttr()); } From e2a5ae98491f5bfd7c039de255fcec3aa97d0a84 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 30 May 2024 14:05:17 -0400 Subject: [PATCH 087/111] remove redundant spaces in my asmprinter code --- llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp index 27ba2e9d7351e..a0d21b9d8965c 100644 --- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -766,7 +766,7 @@ void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) { auto arch = T.getArch(); bool supportMemtagGlobals = false; - + if (arch == Triple::wasm32 || arch == Triple::wasm64) { supportMemtagGlobals = true; } From b334e139e68386e3b79359aeeebb405dd894f1f3 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 30 May 2024 17:12:54 -0400 Subject: [PATCH 088/111] enable wasm32 for toolchains --- clang/lib/Driver/ToolChain.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clang/lib/Driver/ToolChain.cpp b/clang/lib/Driver/ToolChain.cpp index 16ed42e065a4c..1b889c4f10fa3 100644 --- a/clang/lib/Driver/ToolChain.cpp +++ b/clang/lib/Driver/ToolChain.cpp @@ -1378,7 +1378,7 @@ SanitizerMask ToolChain::getSupportedSanitizers() const { getTriple().isAArch64(64) || getTriple().isRISCV()) Res |= SanitizerKind::ShadowCallStack; if (getTriple().isAArch64(64) || - getTriple().getArch() == ::llvm::Triple::wasm64) + getTriple().isWasm()) Res |= SanitizerKind::MemTag; return Res; } From db6702275512a2e611dff3e6275a264954fd9bd0 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 30 May 2024 17:15:31 -0400 Subject: [PATCH 089/111] Fix commonargs to support wasm32 --- clang/lib/Driver/ToolChains/CommonArgs.cpp | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp index 53ba6e2a4cfc6..003de659a19d6 100644 --- a/clang/lib/Driver/ToolChains/CommonArgs.cpp +++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp @@ -1504,10 +1504,7 @@ bool tools::addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args, CmdArgs.push_back("--export-dynamic-symbol=__cfi_check"); if (SanArgs.hasMemTag()) { - if (TC.getTriple().getArch() == ::llvm::Triple::wasm32 - || TC.getTriple().getArch() == ::llvm::Triple::wasm64) - { - + if (TC.getTriple().isWasm()) { } else if (TC.getTriple().isAndroid()) { CmdArgs.push_back( From 33e5289b5ca40b7071028c145e7776f3f2820579 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 30 May 2024 17:22:17 -0400 Subject: [PATCH 090/111] Fix indent --- clang/lib/Driver/ToolChain.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/clang/lib/Driver/ToolChain.cpp b/clang/lib/Driver/ToolChain.cpp index 1b889c4f10fa3..3a0047ef0c9ce 100644 --- a/clang/lib/Driver/ToolChain.cpp +++ b/clang/lib/Driver/ToolChain.cpp @@ -1377,8 +1377,7 @@ SanitizerMask ToolChain::getSupportedSanitizers() const { if (getTriple().getArch() == llvm::Triple::x86_64 || getTriple().isAArch64(64) || getTriple().isRISCV()) Res |= SanitizerKind::ShadowCallStack; - if (getTriple().isAArch64(64) || - getTriple().isWasm()) + if (getTriple().isAArch64(64) || getTriple().isWasm()) Res |= SanitizerKind::MemTag; return Res; } From 41f5028a76ab15c10f375e0c5c35a06b9b776455 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 30 May 2024 17:28:44 -0400 Subject: [PATCH 091/111] Using wasm instead of wasm64 for AsmPrinter --- llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp index a0d21b9d8965c..86c9745dee8fa 100644 --- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -767,7 +767,7 @@ void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) { bool supportMemtagGlobals = false; - if (arch == Triple::wasm32 || arch == Triple::wasm64) { + if (T.isWasm()) { supportMemtagGlobals = true; } else if (arch == Triple::aarch64 && T.isAndroid()) { From 2cb756e0e13479498a1a3228c2287dc7e7c21445 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 30 May 2024 18:12:02 -0400 Subject: [PATCH 092/111] Add wasm32 memtagging in the stack tagging pass --- .../WebAssembly/WebAssemblyStackTagging.cpp | 27 +++++++++++-------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 019b70c64681e..00ed79ad7442b 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -19,6 +19,7 @@ #include "llvm/InitializePasses.h" #include "llvm/Pass.h" #include "llvm/Support/raw_ostream.h" +#include "llvm/Target/TargetMachine.h" #include "llvm/Transforms/Utils/Local.h" #include "llvm/Transforms/Utils/MemoryTaggingSupport.h" @@ -102,6 +103,9 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { if (!Fn.hasFnAttribute(Attribute::SanitizeMemTag)) return false; + Triple triplet(Fn.getParent()->getTargetTriple()); + bool iswasm32 = triplet.getArch() == ::llvm::Triple::wasm32; + F = &Fn; DL = &Fn.getParent()->getDataLayout(); @@ -155,8 +159,9 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { IRBuilder<> IRB(Info.AI->getNextNode()); Type *Int32Type = IRB.getInt32Ty(); Type *Int64Type = IRB.getInt64Ty(); + Type *IntPtrType = iswasm32 ? Int32Type : Int64Type; Function *StoreTagDecl = Intrinsic::getDeclaration( - F->getParent(), Intrinsic::wasm_memory_storetag, {Int64Type}); + F->getParent(), Intrinsic::wasm_memory_storetag, {IntPtrType}); // Calls to functions that may return twice (e.g. setjmp) confuse the // postdominator analysis, and will leave us to keep memory tagged after // function return. Work around this by always untagging at every return @@ -168,10 +173,10 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { !SInfo.CallsReturnTwice; if (StandardLifetime) { auto *HintTagDecl = Intrinsic::getDeclaration( - F->getParent(), Intrinsic::wasm_memory_hinttag, {Int64Type}); - auto *TagPCall = - IRB.CreateCall(HintTagDecl, {ConstantInt::get(Int32Type, 0), Info.AI, - Base, ConstantInt::get(Int64Type, Tag)}); + F->getParent(), Intrinsic::wasm_memory_hinttag, {IntPtrType}); + auto *TagPCall = IRB.CreateCall( + HintTagDecl, {ConstantInt::get(Int32Type, 0), Info.AI, Base, + ConstantInt::get(IntPtrType, Tag)}); if (Info.AI->hasName()) TagPCall->setName(Info.AI->getName() + ".tag"); Info.AI->replaceAllUsesWith(TagPCall); @@ -183,10 +188,10 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { IRBuilder<> IRB2(Start->getNextNode()); IRB2.CreateCall(StoreTagDecl, {ConstantInt::get(Int32Type, 0), TagPCall, - ConstantInt::get(Int64Type, Size)}); + ConstantInt::get(IntPtrType, Size)}); auto TagEnd = [&](Instruction *Node) { - untagAlloca(AI, Node, Size, StoreTagDecl, Int64Type); + untagAlloca(AI, Node, Size, StoreTagDecl, IntPtrType); }; if (!DT || !PDT || !memtag::forAllReachableExits(*DT, *PDT, *LI, Start, Info.LifetimeEnd, @@ -198,17 +203,17 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { uint64_t Size = *Info.AI->getAllocationSize(*DL); auto *HintStoreTagDecl = Intrinsic::getDeclaration( F->getParent(), Intrinsic::wasm_memory_hintstoretag, - {Int64Type, Int64Type}); + {IntPtrType, IntPtrType}); auto *TagPCall = IRB.CreateCall(HintStoreTagDecl, {ConstantInt::get(Int32Type, 0), Info.AI, - ConstantInt::get(Int64Type, Size), Base, - ConstantInt::get(Int64Type, Tag)}); + ConstantInt::get(IntPtrType, Size), Base, + ConstantInt::get(IntPtrType, Tag)}); if (Info.AI->hasName()) TagPCall->setName(Info.AI->getName() + ".tag"); Info.AI->replaceAllUsesWith(TagPCall); TagPCall->setOperand(1, Info.AI); for (auto *RI : SInfo.RetVec) { - untagAlloca(AI, RI, Size, StoreTagDecl, Int64Type); + untagAlloca(AI, RI, Size, StoreTagDecl, IntPtrType); } // We may have inserted tag/untag outside of any lifetime interval. // Remove all lifetime intrinsics for this alloca. From d70a8052d4a5ef519cfae40e64f178d1664ba56b Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 30 May 2024 18:19:03 -0400 Subject: [PATCH 093/111] wasm32 should not use tag that is above 32 bit --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 00ed79ad7442b..5752039ef349c 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -154,6 +154,9 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { TrackingVH OldAI = Info.AI; memtag::alignAndPadAlloca(Info, kTagGranuleSize); uint64_t Tag = NextTag; + if (iswasm32) { + Tag = static_cast(Tag); + } ++NextTag; AllocaInst *AI = Info.AI; IRBuilder<> IRB(Info.AI->getNextNode()); From 567ac0b4805932162a07f3146cf240202561414c Mon Sep 17 00:00:00 2001 From: cqwrteur <100043421+trcrsired@users.noreply.github.com> Date: Sun, 2 Jun 2024 05:17:33 -0400 Subject: [PATCH 094/111] Change instructions Remove add instructions Add more precise manipulation of tags --- .../WebAssembly/WebAssemblyInstrMemtag.td | 205 ++++++------------ 1 file changed, 71 insertions(+), 134 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 03ded52ef3270..593d383121a8f 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -14,195 +14,132 @@ multiclass MemoryTaggingOps { let hasSideEffects = 1 in -defm MEMORY_RANDOMTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src), +defm MEMTAG_RANDOM_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src), (outs), (ins i32imm:$tableidx), [(set rc:$dst, - (int_wasm_memory_randomtag (i32 imm:$tableidx), rc:$src))], - "memory.randomtag\t$dst, $tableidx, $src", - "memory.randomtag\t$tableidx", + (int_wasm_memtag_random (i32 imm:$tableidx), rc:$src))], + "memtag.random\t$dst, $tableidx, $src", + "memtag.random\t$tableidx", 0xfc20>; -defm MEMORY_COPYTAG_A#B: I<(outs rc:$dstwsrctag), (ins i32imm:$tableidx, rc:$dst, rc:$src), +defm MEMTAG_COPY_A#B: I<(outs rc:$dstwsrctag), (ins i32imm:$tableidx, rc:$dst, rc:$src), (outs), (ins i32imm:$tableidx), [(set rc:$dstwsrctag, - (int_wasm_memory_copytag (i32 imm:$tableidx), rc:$dst, rc:$src))], - "memory.copytag\t$dstwsrctag, $tableidx, $dst, $src", - "memory.copytag\t$tableidx", + (int_wasm_memtag_copy (i32 imm:$tableidx), rc:$dst, rc:$src))], + "memtag.copy\t$dstwsrctag, $tableidx, $dst, $src", + "memtag.copy\t$tableidx", 0xfc21>; -defm MEMORY_SUBTAG_A#B: I<(outs rc:$diff), (ins i32imm:$tableidx, rc:$minuendptr, rc:$subtrahendptr), +defm MEMTAG_SUB_A#B: I<(outs rc:$diff), (ins i32imm:$tableidx, rc:$minuendptr, rc:$subtrahendptr), (outs), (ins i32imm:$tableidx), [(set rc:$diff, - (int_wasm_memory_subtag (i32 imm:$tableidx), rc:$minuendptr, rc:$subtrahendptr))], - "memory.subtag\t$diff, $tableidx, $minuendptr, $subtrahendptr", - "memory.subtag\t$tableidx", + (int_wasm_memtag_sub (i32 imm:$tableidx), rc:$minuendptr, rc:$subtrahendptr))], + "memtag.sub\t$diff, $tableidx, $minuendptr, $subtrahendptr", + "memtag.sub\t$tableidx", 0xfc22>; let mayLoad = 1 in -defm MEMORY_LOADTAG_A#B: I<(outs rc:$taggedptr), (ins i32imm:$tableidx, rc:$src), +defm MEMTAG_LOAD_A#B: I<(outs rc:$taggedptr), (ins i32imm:$tableidx, rc:$src), (outs), (ins i32imm:$tableidx), [(set rc:$taggedptr, - (int_wasm_memory_loadtag (i32 imm:$tableidx), rc:$src))], - "memory.loadtag\t$taggedptr, $tableidx, $src", - "memory.loadtag\t$tableidx", + (int_wasm_memtag_load (i32 imm:$tableidx), rc:$src))], + "memtag.load\t$taggedptr, $tableidx, $src", + "memtag.load\t$tableidx", 0xfc23>; let mayStore = 1 in -defm MEMORY_STORETAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), +defm MEMTAG_STORE_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), - [(int_wasm_memory_storetag (i32 imm:$tableidx), rc:$src, rc:$b16)], - "memory.storetag\t$tableidx, $src, $b16", - "memory.storetag\t$tableidx", + [(int_wasm_memtag_store (i32 imm:$tableidx), rc:$src, rc:$b16)], + "memtag.store\t$tableidx, $src, $b16", + "memtag.store\t$tableidx", 0xfc24>; let mayStore = 1 in -defm MEMORY_STOREZTAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), +defm MEMTAG_STOREZ_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), - [(int_wasm_memory_storeztag (i32 imm:$tableidx), rc:$src, rc:$b16)], - "memory.storeztag\t$tableidx, $src, $b16", - "memory.storeztag\t$tableidx", + [(int_wasm_memtag_storez (i32 imm:$tableidx), rc:$src, rc:$b16)], + "memtag.storez\t$tableidx, $src, $b16", + "memtag.storez\t$tableidx", 0xfc25>; -let mayStore = 1 in -defm MEMORY_STORE1TAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), + +let hasSideEffects = 1, mayStore = 1 in +defm MEMTAG_RANDOMSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), - [(int_wasm_memory_store1tag (i32 imm:$tableidx), rc:$src, rc:$b16)], - "memory.store1tag\t$tableidx, $src, $b16", - "memory.store1tag\t$tableidx", + [(set rc:$dst, + (int_wasm_memtag_randomstore (i32 imm:$tableidx), rc:$src, rc:$b16))], + "memtag.randomstore\t$dst, $tableidx, $src, $b16", + "memtag.randomstore\t$tableidx", 0xfc26>; -let mayStore = 1 in -defm MEMORY_STOREZ1TAG_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), +let hasSideEffects = 1, mayStore = 1 in +defm MEMTAG_RANDOMSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), - [(int_wasm_memory_storez1tag (i32 imm:$tableidx), rc:$src, rc:$b16)], - "memory.storez1tag\t$tableidx, $src, $b16", - "memory.storez1tag\t$tableidx", + [(set rc:$dst, + (int_wasm_memtag_randomstorez (i32 imm:$tableidx), rc:$src, rc:$b16))], + "memtag.randomstorez\t$dst, $src, $tableidx, $b16", + "memtag.randomstorez\t$tableidx", 0xfc27>; -let hasSideEffects = 1, mayStore = 1 in -defm MEMORY_RANDOMSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), +defm MEMTAG_HINT_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$hintaddr, rc:$index), (outs), (ins i32imm:$tableidx), [(set rc:$dst, - (int_wasm_memory_randomstoretag (i32 imm:$tableidx), rc:$src, rc:$b16))], - "memory.randomstoretag\t$dst, $tableidx, $src, $b16", - "memory.randomstoretag\t$tableidx", + (int_wasm_memtag_hint (i32 imm:$tableidx), rc:$src, rc:$hintaddr, rc:$index))], + "memtag.hint\t$dst, $tableidx, $src, $hintaddr, $index", + "memtag.hint\t$tableidx", 0xfc28>; -let hasSideEffects = 1, mayStore = 1 in -defm MEMORY_RANDOMSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), +let mayStore = 1 in +defm MEMTAG_HINTSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), (outs), (ins i32imm:$tableidx), [(set rc:$dst, - (int_wasm_memory_randomstoreztag (i32 imm:$tableidx), rc:$src, rc:$b16))], - "memory.randomstoreztag\t$dst, $src, $tableidx, $b16", - "memory.randomstoreztag\t$tableidx", + (int_wasm_memtag_hintstore (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$hintaddr, rc:$index))], + "memtag.hintstore\t$dst, $tableidx, $src, $b16, $hintaddr, $index", + "memtag.hintstore\t$tableidx", 0xfc29>; -let hasSideEffects = 1, mayStore = 1 in -defm MEMORY_RANDOMSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), +let mayStore = 1 in +defm MEMTAG_HINTSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), (outs), (ins i32imm:$tableidx), [(set rc:$dst, - (int_wasm_memory_randomstore1tag (i32 imm:$tableidx), rc:$src, rc:$b16))], - "memory.randomstore1tag\t$dst, $tableidx, $src, $b16", - "memory.randomstore1tag\t$tableidx", + (int_wasm_memtag_hintstorez (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$hintaddr, rc:$index))], + "memtag.hintstorez\t$dst, $tableidx, $src, $b16, $hintaddr, $index", + "memtag.hintstorez\t$tableidx", 0xfc2a>; -let hasSideEffects = 1, mayStore = 1 in -defm MEMORY_RANDOMSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), +defm MEMTAG_CLEAR_A#B: I<(outs rc:$untaggedptr), (ins i32imm:$tableidx, rc:$ptr), (outs), (ins i32imm:$tableidx), - [(set rc:$dst, - (int_wasm_memory_randomstorez1tag (i32 imm:$tableidx), rc:$src, rc:$b16))], - "memory.randomstorez1tag\t$dst, $tableidx, $src, $b16", - "memory.randomstorez1tag\t$tableidx", + [(set rc:$untaggedptr, + (int_wasm_memtag_clear (i32 imm:$tableidx), rc:$ptr))], + "memtag.cleartag\t$untaggedptr, $tableidx, $ptr", + "memtag.cleartag\t$tableidx", 0xfc2b>; -defm MEMORY_HINTTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$hintaddr, rc:$index), +defm MEMTAG_EXTRACT_A#B: I<(outs rc:$taggedval), (ins i32imm:$tableidx, rc:$ptr), (outs), (ins i32imm:$tableidx), - [(set rc:$dst, - (int_wasm_memory_hinttag (i32 imm:$tableidx), rc:$src, rc:$hintaddr, rc:$index))], - "memory.hinttag\t$dst, $tableidx, $src, $hintaddr, $index", - "memory.hinttag\t$tableidx", + [(set rc:$taggedval, + (int_wasm_memtag_extract (i32 imm:$tableidx), rc:$ptr))], + "memtag.extract\t$taggedval, $tableidx, $ptr", + "memtag.extract\t$tableidx", 0xfc2c>; -let mayStore = 1 in -defm MEMORY_HINTSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), +defm MEMTAG_INSERT_A#B: I<(outs rc:$taggedptr), (ins i32imm:$tableidx, rc:$ptr, rc:$insertval), (outs), (ins i32imm:$tableidx), - [(set rc:$dst, - (int_wasm_memory_hintstoretag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$hintaddr, rc:$index))], - "memory.hintstoretag\t$dst, $tableidx, $src, $b16, $hintaddr, $index", - "memory.hintstoretag\t$tableidx", + [(set rc:$taggedptr, + (int_wasm_memtag_insert (i32 imm:$tableidx), rc:$ptr, rc:$insertval))], + "memtag.insert\t$taggedptr, $tableidx, $ptr, $insertval", + "memtag.insert\t$tableidx", 0xfc2d>; -let mayStore = 1 in -defm MEMORY_HINTSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), +defm MEMTAG_TAGBITS_A#B: I<(outs I32:$taggedbits), (ins i32imm:$tableidx, rc:$ptr, rc:$insertval), (outs), (ins i32imm:$tableidx), - [(set rc:$dst, - (int_wasm_memory_hintstoreztag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$hintaddr, rc:$index))], - "memory.hintstoreztag\t$dst, $tableidx, $src, $b16, $hintaddr, $index", - "memory.hintstoreztag\t$tableidx", + [(set rc:$taggedbits, + (int_wasm_memtag_tagbits (i32 imm:$tableidx), rc:$ptr, rc:$insertval))], + "memtag.tagbits\t$taggedbits, $tableidx, $ptr, $insertval", + "memtag.tagbits\t$tableidx", 0xfc2e>; -let mayStore = 1 in -defm MEMORY_HINTSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), - (outs), (ins i32imm:$tableidx), - [(set rc:$dst, - (int_wasm_memory_hintstore1tag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$hintaddr, rc:$index))], - "memory.hintstore1tag\t$dst, $tableidx, $src, $b16, $hintaddr, $index", - "memory.hintstore1tag\t$tableidx", - 0xfc2f>; - -let mayStore = 1 in -defm MEMORY_HINTSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), - (outs), (ins i32imm:$tableidx), - [(set rc:$dst, - (int_wasm_memory_hintstorez1tag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$hintaddr, rc:$index))], - "memory.hintstorez1tag\t$dst, $tableidx, $src, $b16, $hintaddr, $index", - "memory.hintstorez1tag\t$tableidx", - 0xfc30>; - -defm MEMORY_ADDTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$addoffset, rc:$index), - (outs), (ins i32imm:$tableidx), - [(set rc:$dst, - (int_wasm_memory_addtag (i32 imm:$tableidx), rc:$src, rc:$addoffset, rc:$index))], - "memory.addtag\t$dst, $tableidx, $src, $addoffset, $index", - "memory.addtag\t$tableidx", - 0xfc31>; - -let mayStore = 1 in -defm MEMORY_ADDSTORETAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addoffset, rc:$index), - (outs), (ins i32imm:$tableidx), - [(set rc:$dst, - (int_wasm_memory_addstoretag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$addoffset, rc:$index))], - "memory.addstoretag\t$dst, $tableidx, $src, $b16, $addoffset, $index", - "memory.addstoretag\t$tableidx", - 0xfc32>; - -let mayStore = 1 in -defm MEMORY_ADDSTOREZTAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addoffset, rc:$index), - (outs), (ins i32imm:$tableidx), - [(set rc:$dst, - (int_wasm_memory_addstoreztag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$addoffset, rc:$index))], - "memory.addstoreztag\t$dst, $tableidx, $src, $b16, $addoffset, $index", - "memory.addstoreztag\t$tableidx", - 0xfc33>; - -let mayStore = 1 in -defm MEMORY_ADDSTORE1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addoffset, rc:$index), - (outs), (ins i32imm:$tableidx), - [(set rc:$dst, - (int_wasm_memory_addstore1tag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$addoffset, rc:$index))], - "memory.addstore1tag\t$dst, $tableidx, $src, $b16, $addoffset, $index", - "memory.addstore1tag\t$tableidx", - 0xfc34>; - -let mayStore = 1 in -defm MEMORY_ADDSTOREZ1TAG_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addoffset, rc:$index), - (outs), (ins i32imm:$tableidx), - [(set rc:$dst, - (int_wasm_memory_addstorez1tag (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$addoffset, rc:$index))], - "memory.addstorez1tag\t$dst, $tableidx, $src, $b16, $addoffset, $index", - "memory.addstorez1tag\t$tableidx", - 0xfc35>; - } defm : MemoryTaggingOps; From b770857412b362dd846934f754d3666d9fdbd38a Mon Sep 17 00:00:00 2001 From: cqwrteur <100043421+trcrsired@users.noreply.github.com> Date: Sun, 2 Jun 2024 05:59:17 -0400 Subject: [PATCH 095/111] Rename intrinsics and builtins for wasm mtg. Remove pointless builtins and add extras --- .../clang/Basic/BuiltinsWebAssembly.def | 37 ++--- clang/lib/CodeGen/CGBuiltin.cpp | 145 +++++------------- llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 81 ++++------ .../WebAssembly/WebAssemblyInstrMemtag.td | 6 +- .../WebAssembly/WebAssemblyStackTagging.cpp | 8 +- 5 files changed, 89 insertions(+), 188 deletions(-) diff --git a/clang/include/clang/Basic/BuiltinsWebAssembly.def b/clang/include/clang/Basic/BuiltinsWebAssembly.def index 075c652eeb6e6..f2ee93c471eaf 100644 --- a/clang/include/clang/Basic/BuiltinsWebAssembly.def +++ b/clang/include/clang/Basic/BuiltinsWebAssembly.def @@ -26,28 +26,21 @@ BUILTIN(__builtin_wasm_memory_size, "zIi", "n") BUILTIN(__builtin_wasm_memory_grow, "zIiz", "n") // Memory Tagging -BUILTIN(__builtin_wasm_memory_randomtag, "v*Iiv*", "n") -BUILTIN(__builtin_wasm_memory_copytag, "v*Iiv*v*", "n") -BUILTIN(__builtin_wasm_memory_subtag, "YIiv*v*", "n") -BUILTIN(__builtin_wasm_memory_loadtag, "v*Iiv*", "n") -BUILTIN(__builtin_wasm_memory_storetag, "vIiv*z", "n") -BUILTIN(__builtin_wasm_memory_storeztag, "vIiv*z", "n") -BUILTIN(__builtin_wasm_memory_store1tag, "vIiv*z", "n") -BUILTIN(__builtin_wasm_memory_storez1tag, "vIiv*z", "n") -BUILTIN(__builtin_wasm_memory_randomstoretag, "v*Iiv*z", "n") -BUILTIN(__builtin_wasm_memory_randomstoreztag, "v*Iiv*z", "n") -BUILTIN(__builtin_wasm_memory_randomstore1tag, "v*Iiv*z", "n") -BUILTIN(__builtin_wasm_memory_randomstorez1tag, "v*Iiv*z", "n") -BUILTIN(__builtin_wasm_memory_hinttag, "v*Iiv*v*z", "n") -BUILTIN(__builtin_wasm_memory_hintstoretag, "v*Iiv*zv*z", "n") -BUILTIN(__builtin_wasm_memory_hintstoreztag, "v*Iiv*zv*z", "n") -BUILTIN(__builtin_wasm_memory_hintstore1tag, "v*Iiv*zv*z", "n") -BUILTIN(__builtin_wasm_memory_hintstorez1tag, "v*Iiv*zv*z", "n") -BUILTIN(__builtin_wasm_memory_addtag, "v*Iiv*Yz", "n") -BUILTIN(__builtin_wasm_memory_addstoretag, "v*Iiv*zYz", "n") -BUILTIN(__builtin_wasm_memory_addstoreztag, "v*Iiv*zYz", "n") -BUILTIN(__builtin_wasm_memory_addstore1tag, "v*Iiv*zYz", "n") -BUILTIN(__builtin_wasm_memory_addstorez1tag, "v*Iiv*zYz", "n") +BUILTIN(__builtin_wasm_memtag_random, "v*Iiv*", "n") +BUILTIN(__builtin_wasm_memtag_copy, "v*Iiv*v*", "n") +BUILTIN(__builtin_wasm_memtag_sub, "YIiv*v*", "n") +BUILTIN(__builtin_wasm_memtag_load, "v*Iiv*", "n") +BUILTIN(__builtin_wasm_memtag_store, "vIiv*z", "n") +BUILTIN(__builtin_wasm_memtag_storez, "vIiv*z", "n") +BUILTIN(__builtin_wasm_memtag_randomstore, "v*Iiv*z", "n") +BUILTIN(__builtin_wasm_memtag_randomstorez, "v*Iiv*z", "n") +BUILTIN(__builtin_wasm_memtag_hint, "v*Iiv*v*z", "n") +BUILTIN(__builtin_wasm_memtag_hintstore, "v*Iiv*zv*z", "n") +BUILTIN(__builtin_wasm_memtag_hintstorez, "v*Iiv*zv*z", "n") +BUILTIN(__builtin_wasm_memtag_clear, "v*Iiv*", "n") +BUILTIN(__builtin_wasm_memtag_extract, "zIiv*", "n") +BUILTIN(__builtin_wasm_memtag_insert, "v*Iiv*z", "n") +BUILTIN(__builtin_wasm_memtag_tagbits, "UiIi", "n") // Thread-local storage TARGET_BUILTIN(__builtin_wasm_tls_size, "z", "nc", "bulk-memory") diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index e18513c5ee6c0..7931c431c783f 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -21350,184 +21350,113 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, return Builder.CreateCall(Callee, {TableX, TableY, SrcIdx, DstIdx, NElems}); } - case WebAssembly::BI__builtin_wasm_memory_randomtag: { - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomtag); + case WebAssembly::BI__builtin_wasm_memtag_random: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_random); Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); return Builder.CreateCall(Callee, {Index, Ptr}); } - case WebAssembly::BI__builtin_wasm_memory_copytag: { - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_copytag); + case WebAssembly::BI__builtin_wasm_memtag_copy: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_copy); Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr0 = EmitScalarExpr(E->getArg(1)); Value *Ptr1 = EmitScalarExpr(E->getArg(2)); return Builder.CreateCall(Callee, {Index, Ptr0, Ptr1}); } - case WebAssembly::BI__builtin_wasm_memory_subtag: { - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_subtag, ConvertType(E->getType())); + case WebAssembly::BI__builtin_wasm_memtag_sub: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_sub, ConvertType(E->getType())); Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr0 = EmitScalarExpr(E->getArg(1)); Value *Ptr1 = EmitScalarExpr(E->getArg(2)); return Builder.CreateCall(Callee, {Index, Ptr0, Ptr1}); } - case WebAssembly::BI__builtin_wasm_memory_loadtag: { - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_loadtag); + case WebAssembly::BI__builtin_wasm_memtag_load: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_load); Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); return Builder.CreateCall(Callee, {Index, Ptr}); } - case WebAssembly::BI__builtin_wasm_memory_storetag: { + case WebAssembly::BI__builtin_wasm_memtag_store: { Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *B16 = EmitScalarExpr(E->getArg(2)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storetag, B16->getType()); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_store, B16->getType()); return Builder.CreateCall(Callee, {Index, Ptr, B16}); } - case WebAssembly::BI__builtin_wasm_memory_storeztag: { + case WebAssembly::BI__builtin_wasm_memtag_storez: { Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *B16 = EmitScalarExpr(E->getArg(2)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storeztag, B16->getType()); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_storez, B16->getType()); return Builder.CreateCall(Callee, {Index, Ptr, B16}); } - case WebAssembly::BI__builtin_wasm_memory_store1tag: { + case WebAssembly::BI__builtin_wasm_memtag_randomstore: { Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *B16 = EmitScalarExpr(E->getArg(2)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_store1tag, B16->getType()); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_randomstore, B16->getType()); return Builder.CreateCall(Callee, {Index, Ptr, B16}); } - case WebAssembly::BI__builtin_wasm_memory_storez1tag: { + case WebAssembly::BI__builtin_wasm_memtag_randomstorez: { Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *B16 = EmitScalarExpr(E->getArg(2)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_storez1tag, B16->getType()); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_randomstorez, B16->getType()); return Builder.CreateCall(Callee, {Index, Ptr, B16}); } - case WebAssembly::BI__builtin_wasm_memory_randomstoretag: { - Value *Index = EmitScalarExpr(E->getArg(0)); - Value *Ptr = EmitScalarExpr(E->getArg(1)); - Value *B16 = EmitScalarExpr(E->getArg(2)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstoretag, B16->getType()); - return Builder.CreateCall(Callee, {Index, Ptr, B16}); - } - case WebAssembly::BI__builtin_wasm_memory_randomstoreztag: { - Value *Index = EmitScalarExpr(E->getArg(0)); - Value *Ptr = EmitScalarExpr(E->getArg(1)); - Value *B16 = EmitScalarExpr(E->getArg(2)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstoreztag, B16->getType()); - return Builder.CreateCall(Callee, {Index, Ptr, B16}); - } - case WebAssembly::BI__builtin_wasm_memory_randomstore1tag: { - Value *Index = EmitScalarExpr(E->getArg(0)); - Value *Ptr = EmitScalarExpr(E->getArg(1)); - Value *B16 = EmitScalarExpr(E->getArg(2)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstore1tag, B16->getType()); - return Builder.CreateCall(Callee, {Index, Ptr, B16}); - } - case WebAssembly::BI__builtin_wasm_memory_randomstorez1tag: { - Value *Index = EmitScalarExpr(E->getArg(0)); - Value *Ptr = EmitScalarExpr(E->getArg(1)); - Value *B16 = EmitScalarExpr(E->getArg(2)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_randomstorez1tag, B16->getType()); - return Builder.CreateCall(Callee, {Index, Ptr, B16}); - } - case WebAssembly::BI__builtin_wasm_memory_hinttag: { + case WebAssembly::BI__builtin_wasm_memtag_hint: { Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *HintPtr = EmitScalarExpr(E->getArg(2)); Value *HintIdx = EmitScalarExpr(E->getArg(3)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_hinttag, HintIdx->getType()); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_hint, HintIdx->getType()); return Builder.CreateCall(Callee, {Index, Ptr, HintPtr, HintIdx}); } - case WebAssembly::BI__builtin_wasm_memory_hintstoretag: { + case WebAssembly::BI__builtin_wasm_memtag_hintstore: { Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *B16 = EmitScalarExpr(E->getArg(2)); Value *HintPtr = EmitScalarExpr(E->getArg(3)); Value *HintIdx = EmitScalarExpr(E->getArg(4)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_hintstoretag, + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_hintstore, {B16->getType(), HintIdx->getType()}); return Builder.CreateCall(Callee, {Index, Ptr, B16, HintPtr, HintIdx}); } - case WebAssembly::BI__builtin_wasm_memory_hintstoreztag: { + case WebAssembly::BI__builtin_wasm_memtag_hintstorez: { Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); Value *B16 = EmitScalarExpr(E->getArg(2)); Value *HintPtr = EmitScalarExpr(E->getArg(3)); Value *HintIdx = EmitScalarExpr(E->getArg(4)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_hintstoreztag, + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_hintstorez, {B16->getType(), HintIdx->getType()}); return Builder.CreateCall(Callee, {Index, Ptr, B16, HintPtr, HintIdx}); } - case WebAssembly::BI__builtin_wasm_memory_hintstore1tag: { + case WebAssembly::BI__builtin_wasm_memtag_clear: { Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); - Value *B16 = EmitScalarExpr(E->getArg(2)); - Value *HintPtr = EmitScalarExpr(E->getArg(3)); - Value *HintIdx = EmitScalarExpr(E->getArg(4)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_hintstore1tag, - {B16->getType(), HintIdx->getType()}); - return Builder.CreateCall(Callee, {Index, Ptr, B16, HintPtr, HintIdx}); - } - case WebAssembly::BI__builtin_wasm_memory_hintstorez1tag: { - Value *Index = EmitScalarExpr(E->getArg(0)); - Value *Ptr = EmitScalarExpr(E->getArg(1)); - Value *B16 = EmitScalarExpr(E->getArg(2)); - Value *HintPtr = EmitScalarExpr(E->getArg(3)); - Value *HintIdx = EmitScalarExpr(E->getArg(4)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_hintstorez1tag, - {B16->getType(), HintIdx->getType()}); - return Builder.CreateCall(Callee, {Index, Ptr, B16, HintPtr, HintIdx}); - } - case WebAssembly::BI__builtin_wasm_memory_addtag: { - Value *Index = EmitScalarExpr(E->getArg(0)); - Value *Ptr = EmitScalarExpr(E->getArg(1)); - Value *Offset = EmitScalarExpr(E->getArg(2)); - Value *HintIdx = EmitScalarExpr(E->getArg(3)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_addtag, - {Offset->getType(), HintIdx->getType()}); - return Builder.CreateCall(Callee, {Index, Ptr, Offset, HintIdx}); - } - case WebAssembly::BI__builtin_wasm_memory_addstoretag: { - Value *Index = EmitScalarExpr(E->getArg(0)); - Value *Ptr = EmitScalarExpr(E->getArg(1)); - Value *B16 = EmitScalarExpr(E->getArg(2)); - Value *Offset = EmitScalarExpr(E->getArg(3)); - Value *HintIdx = EmitScalarExpr(E->getArg(4)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_hintstoretag, - {B16->getType(), Offset->getType(), HintIdx->getType()}); - return Builder.CreateCall(Callee, {Index, Ptr, B16, Offset, HintIdx}); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_clear); + return Builder.CreateCall(Callee, {Index, Ptr}); } - case WebAssembly::BI__builtin_wasm_memory_addstoreztag: { + case WebAssembly::BI__builtin_wasm_memtag_extract: { Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); - Value *B16 = EmitScalarExpr(E->getArg(2)); - Value *Offset = EmitScalarExpr(E->getArg(3)); - Value *HintIdx = EmitScalarExpr(E->getArg(4)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_addstoreztag, - {B16->getType(), Offset->getType(), HintIdx->getType()}); - return Builder.CreateCall(Callee, {Index, Ptr, B16, Offset, HintIdx}); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_extract, + {ConvertType(E->getType())}); + return Builder.CreateCall(Callee, {Index, Ptr}); } - case WebAssembly::BI__builtin_wasm_memory_addstore1tag: { + case WebAssembly::BI__builtin_wasm_memtag_insert: { Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); - Value *B16 = EmitScalarExpr(E->getArg(2)); - Value *Offset = EmitScalarExpr(E->getArg(3)); - Value *HintIdx = EmitScalarExpr(E->getArg(4)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_addstore1tag, - {B16->getType(), Offset->getType(), HintIdx->getType()}); - return Builder.CreateCall(Callee, {Index, Ptr, B16, Offset, HintIdx}); + Value *Newtag = EmitScalarExpr(E->getArg(2)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_insert, + {Newtag->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, Newtag}); } - case WebAssembly::BI__builtin_wasm_memory_addstorez1tag: { + case WebAssembly::BI__builtin_wasm_memtag_tagbits: { Value *Index = EmitScalarExpr(E->getArg(0)); - Value *Ptr = EmitScalarExpr(E->getArg(1)); - Value *B16 = EmitScalarExpr(E->getArg(2)); - Value *Offset = EmitScalarExpr(E->getArg(3)); - Value *HintIdx = EmitScalarExpr(E->getArg(4)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_addstorez1tag, - {B16->getType(), Offset->getType(), HintIdx->getType()}); - return Builder.CreateCall(Callee, {Index, Ptr, B16, Offset, HintIdx}); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_tagbits); + return Builder.CreateCall(Callee, {Index}); } default: return nullptr; diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index 6815f29c90911..8b19b3720e0f1 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -388,70 +388,49 @@ def int_wasm_tls_base : // Memory Tagging intrinsics //===----------------------------------------------------------------------===// -def int_wasm_memory_randomtag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem, IntrHasSideEffects], "llvm.wasm.memory.randomtag">; +def int_wasm_memtag_random : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem, IntrHasSideEffects], "llvm.wasm.memtag.random">; -def int_wasm_memory_copytag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.copytag">; +def int_wasm_memtag_copy : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memtag.copy">; -def int_wasm_memory_subtag : - DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memory.subtag">; +def int_wasm_memtag_sub : + DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memtag.sub">; -def int_wasm_memory_loadtag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrReadMem], "llvm.wasm.memory.loadtag">; +def int_wasm_memtag_load : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrReadMem], "llvm.wasm.memtag.load">; -def int_wasm_memory_storetag : - DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.storetag">; +def int_wasm_memtag_store : + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.store">; -def int_wasm_memory_storeztag : - DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.storeztag">; +def int_wasm_memtag_storez : + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.storez">; -def int_wasm_memory_store1tag : - DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.store1tag">; +def int_wasm_memtag_randomstore : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memtag.randomstore">; -def int_wasm_memory_storez1tag : - DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.storez1tag">; +def int_wasm_memtag_randomstorez : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memtag.randomstorez">; -def int_wasm_memory_randomstoretag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.randomstoretag">; +def int_wasm_memtag_hint : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memtag.hint">; -def int_wasm_memory_randomstoreztag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.randomstoreztag">; +def int_wasm_memtag_hintstore : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.hintstore">; -def int_wasm_memory_randomstore1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.randomstore1tag">; +def int_wasm_memtag_hintstorez : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.hintstorez">; -def int_wasm_memory_randomstorez1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memory.randomstorez1tag">; +def int_wasm_memtag_clear : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memtag.clear">; -def int_wasm_memory_hinttag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memory.hinttag">; +def int_wasm_memtag_extract : + DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memtag.extract">; -def int_wasm_memory_hintstoretag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.hintstoretag">; +def int_wasm_memtag_insert : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memtag.insert">; -def int_wasm_memory_hintstoreztag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.hintstoreztag">; - -def int_wasm_memory_hintstore1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.hintstore1tag">; - -def int_wasm_memory_hintstorez1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.hintstorez1tag">; - -def int_wasm_memory_addtag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memory.addtag">; - -def int_wasm_memory_addstoretag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.addstoretag">; - -def int_wasm_memory_addstoreztag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.addstoreztag">; - -def int_wasm_memory_addstore1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.addstore1tag">; - -def int_wasm_memory_addstorez1tag : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memory.addstorez1tag">; +def int_wasm_memtag_tagbits : + DefaultAttrsIntrinsic<[llvm_i32_ty], [llvm_i32_ty], [IntrNoMem], "llvm.wasm.memtag.tagbits">; } // TargetPrefix = "wasm" diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 593d383121a8f..fda606646fbc8 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -132,11 +132,11 @@ defm MEMTAG_INSERT_A#B: I<(outs rc:$taggedptr), (ins i32imm:$tableidx, rc:$ptr, "memtag.insert\t$tableidx", 0xfc2d>; -defm MEMTAG_TAGBITS_A#B: I<(outs I32:$taggedbits), (ins i32imm:$tableidx, rc:$ptr, rc:$insertval), +defm MEMTAG_TAGBITS_A#B: I<(outs I32:$taggedbits), (ins i32imm:$tableidx), (outs), (ins i32imm:$tableidx), [(set rc:$taggedbits, - (int_wasm_memtag_tagbits (i32 imm:$tableidx), rc:$ptr, rc:$insertval))], - "memtag.tagbits\t$taggedbits, $tableidx, $ptr, $insertval", + (int_wasm_memtag_tagbits (i32 imm:$tableidx)))], + "memtag.tagbits\t$taggedbits, $tableidx", "memtag.tagbits\t$tableidx", 0xfc2e>; diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 5752039ef349c..e86a2e2e971eb 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -91,7 +91,7 @@ Instruction *WebAssemblyStackTagging::insertBaseTaggedPointer( IRBuilder<> IRB(&PrologueBB->front()); Function *RdTag = Intrinsic::getDeclaration(F->getParent(), - Intrinsic::wasm_memory_randomtag); + Intrinsic::wasm_memtag_random); Instruction *Base = IRB.CreateCall(RdTag, {IRB.getInt32(0), ::llvm::ConstantPointerNull::get(IRB.getPtrTy())}); @@ -164,7 +164,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { Type *Int64Type = IRB.getInt64Ty(); Type *IntPtrType = iswasm32 ? Int32Type : Int64Type; Function *StoreTagDecl = Intrinsic::getDeclaration( - F->getParent(), Intrinsic::wasm_memory_storetag, {IntPtrType}); + F->getParent(), Intrinsic::wasm_memtag_store, {IntPtrType}); // Calls to functions that may return twice (e.g. setjmp) confuse the // postdominator analysis, and will leave us to keep memory tagged after // function return. Work around this by always untagging at every return @@ -176,7 +176,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { !SInfo.CallsReturnTwice; if (StandardLifetime) { auto *HintTagDecl = Intrinsic::getDeclaration( - F->getParent(), Intrinsic::wasm_memory_hinttag, {IntPtrType}); + F->getParent(), Intrinsic::wasm_memtag_hint, {IntPtrType}); auto *TagPCall = IRB.CreateCall( HintTagDecl, {ConstantInt::get(Int32Type, 0), Info.AI, Base, ConstantInt::get(IntPtrType, Tag)}); @@ -205,7 +205,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { } else { uint64_t Size = *Info.AI->getAllocationSize(*DL); auto *HintStoreTagDecl = Intrinsic::getDeclaration( - F->getParent(), Intrinsic::wasm_memory_hintstoretag, + F->getParent(), Intrinsic::wasm_memtag_hintstore, {IntPtrType, IntPtrType}); auto *TagPCall = IRB.CreateCall(HintStoreTagDecl, {ConstantInt::get(Int32Type, 0), Info.AI, From cb637421acb7bec02524ffaa53dc7d912054e6dc Mon Sep 17 00:00:00 2001 From: cqwrteur <100043421+trcrsired@users.noreply.github.com> Date: Sun, 2 Jun 2024 13:53:28 -0400 Subject: [PATCH 096/111] fix i32 --- llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index fda606646fbc8..61bbcf67f1dbe 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -132,9 +132,9 @@ defm MEMTAG_INSERT_A#B: I<(outs rc:$taggedptr), (ins i32imm:$tableidx, rc:$ptr, "memtag.insert\t$tableidx", 0xfc2d>; -defm MEMTAG_TAGBITS_A#B: I<(outs I32:$taggedbits), (ins i32imm:$tableidx), +defm MEMTAG_TAGBITS_A#B: I<(outs i32:$taggedbits), (ins i32imm:$tableidx), (outs), (ins i32imm:$tableidx), - [(set rc:$taggedbits, + [(set i32:$taggedbits, (int_wasm_memtag_tagbits (i32 imm:$tableidx)))], "memtag.tagbits\t$taggedbits, $tableidx", "memtag.tagbits\t$tableidx", From 0901488a3fd6baad34276c4a97a64a21a3c01c64 Mon Sep 17 00:00:00 2001 From: cqwrteur <100043421+trcrsired@users.noreply.github.com> Date: Sun, 2 Jun 2024 15:59:08 -0400 Subject: [PATCH 097/111] Change instructions --- .../clang/Basic/BuiltinsWebAssembly.def | 20 +- clang/lib/CodeGen/CGBuiltin.cpp | 136 ++++++++++--- llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 58 ++++-- .../WebAssembly/WebAssemblyInstrMemtag.td | 189 +++++++++++++----- 4 files changed, 308 insertions(+), 95 deletions(-) diff --git a/clang/include/clang/Basic/BuiltinsWebAssembly.def b/clang/include/clang/Basic/BuiltinsWebAssembly.def index f2ee93c471eaf..bebf27a5a19f5 100644 --- a/clang/include/clang/Basic/BuiltinsWebAssembly.def +++ b/clang/include/clang/Basic/BuiltinsWebAssembly.def @@ -26,21 +26,31 @@ BUILTIN(__builtin_wasm_memory_size, "zIi", "n") BUILTIN(__builtin_wasm_memory_grow, "zIiz", "n") // Memory Tagging -BUILTIN(__builtin_wasm_memtag_random, "v*Iiv*", "n") +BUILTIN(__builtin_wasm_memtag_status, "ziIi", "n") +BUILTIN(__builtin_wasm_memtag_tagbits, "ziIi", "n") +BUILTIN(__builtin_wasm_memtag_startbit, "ziIi", "n") +BUILTIN(__builtin_wasm_memtag_extract, "zIiv*", "n") +BUILTIN(__builtin_wasm_memtag_insert, "v*Iiv*z", "n") BUILTIN(__builtin_wasm_memtag_copy, "v*Iiv*v*", "n") BUILTIN(__builtin_wasm_memtag_sub, "YIiv*v*", "n") BUILTIN(__builtin_wasm_memtag_load, "v*Iiv*", "n") BUILTIN(__builtin_wasm_memtag_store, "vIiv*z", "n") BUILTIN(__builtin_wasm_memtag_storez, "vIiv*z", "n") +BUILTIN(__builtin_wasm_memtag_untag, "v*Iiv*", "n") +BUILTIN(__builtin_wasm_memtag_untagstore, "v*Iiv*z", "n") +BUILTIN(__builtin_wasm_memtag_untagstorez, "v*Iiv*z", "n") +BUILTIN(__builtin_wasm_memtag_random, "v*Iiv*", "n") BUILTIN(__builtin_wasm_memtag_randomstore, "v*Iiv*z", "n") BUILTIN(__builtin_wasm_memtag_randomstorez, "v*Iiv*z", "n") +BUILTIN(__builtin_wasm_memtag_randommask, "v*Iiv*", "n") +BUILTIN(__builtin_wasm_memtag_randommaskstore, "v*Iiv*z", "n") +BUILTIN(__builtin_wasm_memtag_randommaskstorez, "v*Iiv*z", "n") +BUILTIN(__builtin_wasm_memtag_add, "v*Iiv*zz", "n") +BUILTIN(__builtin_wasm_memtag_addstore, "v*Iiv*zz", "n") +BUILTIN(__builtin_wasm_memtag_addstorez, "v*Iiv*zz", "n") BUILTIN(__builtin_wasm_memtag_hint, "v*Iiv*v*z", "n") BUILTIN(__builtin_wasm_memtag_hintstore, "v*Iiv*zv*z", "n") BUILTIN(__builtin_wasm_memtag_hintstorez, "v*Iiv*zv*z", "n") -BUILTIN(__builtin_wasm_memtag_clear, "v*Iiv*", "n") -BUILTIN(__builtin_wasm_memtag_extract, "zIiv*", "n") -BUILTIN(__builtin_wasm_memtag_insert, "v*Iiv*z", "n") -BUILTIN(__builtin_wasm_memtag_tagbits, "UiIi", "n") // Thread-local storage TARGET_BUILTIN(__builtin_wasm_tls_size, "z", "nc", "bulk-memory") diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 7931c431c783f..56c9d544d77b5 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -21350,12 +21350,39 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, return Builder.CreateCall(Callee, {TableX, TableY, SrcIdx, DstIdx, NElems}); } - case WebAssembly::BI__builtin_wasm_memtag_random: { - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_random); + case WebAssembly::BI__builtin_wasm_memtag_status: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_status, + {ConvertType(E->getType())}); + return Builder.CreateCall(Callee, {Index}); + } + case WebAssembly::BI__builtin_wasm_memtag_tagbits: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_tagbits, + {ConvertType(E->getType())}); + return Builder.CreateCall(Callee, {Index}); + } + case WebAssembly::BI__builtin_wasm_memtag_startbit: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_startbit, + {ConvertType(E->getType())}); + return Builder.CreateCall(Callee, {Index}); + } + case WebAssembly::BI__builtin_wasm_memtag_extract: { Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_extract, + {ConvertType(E->getType())}); return Builder.CreateCall(Callee, {Index, Ptr}); } + case WebAssembly::BI__builtin_wasm_memtag_insert: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *Newtag = EmitScalarExpr(E->getArg(2)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_insert, + {Newtag->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, Newtag}); + } case WebAssembly::BI__builtin_wasm_memtag_copy: { Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_copy); Value *Index = EmitScalarExpr(E->getArg(0)); @@ -21390,6 +21417,32 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_storez, B16->getType()); return Builder.CreateCall(Callee, {Index, Ptr, B16}); } + case WebAssembly::BI__builtin_wasm_memtag_untag: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_untag); + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + return Builder.CreateCall(Callee, {Index, Ptr}); + } + case WebAssembly::BI__builtin_wasm_memtag_untagstore: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_untagstore, B16->getType()); + return Builder.CreateCall(Callee, {Index, Ptr, B16}); + } + case WebAssembly::BI__builtin_wasm_memtag_untagstorez: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_untagstorez, B16->getType()); + return Builder.CreateCall(Callee, {Index, Ptr, B16}); + } + case WebAssembly::BI__builtin_wasm_memtag_random: { + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_random); + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + return Builder.CreateCall(Callee, {Index, Ptr}); + } case WebAssembly::BI__builtin_wasm_memtag_randomstore: { Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); @@ -21404,6 +21457,59 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_randomstorez, B16->getType()); return Builder.CreateCall(Callee, {Index, Ptr, B16}); } + case WebAssembly::BI__builtin_wasm_memtag_randommask: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *Mask = EmitScalarExpr(E->getArg(2)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_random, Mask->getType()); + return Builder.CreateCall(Callee, {Index, Ptr, Mask}); + } + case WebAssembly::BI__builtin_wasm_memtag_randommaskstore: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); + Value *Mask = EmitScalarExpr(E->getArg(3)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_randomstore, + {B16->getType(), Mask->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, B16, Mask}); + } + case WebAssembly::BI__builtin_wasm_memtag_randommaskstorez: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); + Value *Mask = EmitScalarExpr(E->getArg(3)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_randomstorez, + {B16->getType(), Mask->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, B16, Mask}); + } + case WebAssembly::BI__builtin_wasm_memtag_add: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *PtrOffset = EmitScalarExpr(E->getArg(2)); + Value *TagOffset = EmitScalarExpr(E->getArg(3)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_add, TagOffset->getType()); + return Builder.CreateCall(Callee, {Index, Ptr, PtrOffset, TagOffset}); + } + case WebAssembly::BI__builtin_wasm_memtag_addstore: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); + Value *PtrOffset = EmitScalarExpr(E->getArg(3)); + Value *TagOffset = EmitScalarExpr(E->getArg(4)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_addstore, + {B16->getType(), TagOffset->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, B16, PtrOffset, TagOffset}); + } + case WebAssembly::BI__builtin_wasm_memtag_addstorez: { + Value *Index = EmitScalarExpr(E->getArg(0)); + Value *Ptr = EmitScalarExpr(E->getArg(1)); + Value *B16 = EmitScalarExpr(E->getArg(2)); + Value *PtrOffset = EmitScalarExpr(E->getArg(3)); + Value *TagOffset = EmitScalarExpr(E->getArg(4)); + Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_addstorez, + {B16->getType(), TagOffset->getType()}); + return Builder.CreateCall(Callee, {Index, Ptr, B16, PtrOffset, TagOffset}); + } case WebAssembly::BI__builtin_wasm_memtag_hint: { Value *Index = EmitScalarExpr(E->getArg(0)); Value *Ptr = EmitScalarExpr(E->getArg(1)); @@ -21432,32 +21538,6 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID, {B16->getType(), HintIdx->getType()}); return Builder.CreateCall(Callee, {Index, Ptr, B16, HintPtr, HintIdx}); } - case WebAssembly::BI__builtin_wasm_memtag_clear: { - Value *Index = EmitScalarExpr(E->getArg(0)); - Value *Ptr = EmitScalarExpr(E->getArg(1)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_clear); - return Builder.CreateCall(Callee, {Index, Ptr}); - } - case WebAssembly::BI__builtin_wasm_memtag_extract: { - Value *Index = EmitScalarExpr(E->getArg(0)); - Value *Ptr = EmitScalarExpr(E->getArg(1)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_extract, - {ConvertType(E->getType())}); - return Builder.CreateCall(Callee, {Index, Ptr}); - } - case WebAssembly::BI__builtin_wasm_memtag_insert: { - Value *Index = EmitScalarExpr(E->getArg(0)); - Value *Ptr = EmitScalarExpr(E->getArg(1)); - Value *Newtag = EmitScalarExpr(E->getArg(2)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_insert, - {Newtag->getType()}); - return Builder.CreateCall(Callee, {Index, Ptr, Newtag}); - } - case WebAssembly::BI__builtin_wasm_memtag_tagbits: { - Value *Index = EmitScalarExpr(E->getArg(0)); - Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_tagbits); - return Builder.CreateCall(Callee, {Index}); - } default: return nullptr; } diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index 8b19b3720e0f1..b8d65ee7f734f 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -388,8 +388,20 @@ def int_wasm_tls_base : // Memory Tagging intrinsics //===----------------------------------------------------------------------===// -def int_wasm_memtag_random : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem, IntrHasSideEffects], "llvm.wasm.memtag.random">; +def int_wasm_memtag_status : + DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_i32_ty], [IntrNoMem], "llvm.wasm.memtag.status">; + +def int_wasm_memtag_tagbits : + DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_i32_ty], [IntrNoMem], "llvm.wasm.memtag.tagbits">; + +def int_wasm_memtag_startbit : + DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_i32_ty], [IntrNoMem], "llvm.wasm.memtag.startbit">; + +def int_wasm_memtag_extract : + DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memtag.extract">; + +def int_wasm_memtag_insert : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memtag.insert">; def int_wasm_memtag_copy : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memtag.copy">; @@ -400,18 +412,48 @@ def int_wasm_memtag_sub : def int_wasm_memtag_load : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrReadMem], "llvm.wasm.memtag.load">; +def int_wasm_memtag_untag : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memtag.untag">; + +def int_wasm_memtag_untagstore : + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.untagstore">; + +def int_wasm_memtag_untagstorez : + DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.untagstorez">; + def int_wasm_memtag_store : DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.store">; def int_wasm_memtag_storez : DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.storez">; +def int_wasm_memtag_random : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem, IntrHasSideEffects], "llvm.wasm.memtag.random">; + def int_wasm_memtag_randomstore : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memtag.randomstore">; def int_wasm_memtag_randomstorez : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memtag.randomstorez">; +def int_wasm_memtag_randommask : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem, IntrHasSideEffects], "llvm.wasm.memtag.randommask">; + +def int_wasm_memtag_randommaskstore : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memtag.randommaskstore">; + +def int_wasm_memtag_randommaskstorez : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrHasSideEffects, IntrWriteMem], "llvm.wasm.memtag.randommaskstorez">; + +def int_wasm_memtag_add : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memtag.add">; + +def int_wasm_memtag_addstore : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.addstore">; + +def int_wasm_memtag_addstorez : + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_anyint_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.addstorez">; + def int_wasm_memtag_hint : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memtag.hint">; @@ -421,16 +463,4 @@ def int_wasm_memtag_hintstore : def int_wasm_memtag_hintstorez : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.hintstorez">; -def int_wasm_memtag_clear : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memtag.clear">; - -def int_wasm_memtag_extract : - DefaultAttrsIntrinsic<[llvm_anyint_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memtag.extract">; - -def int_wasm_memtag_insert : - DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrNoMem], "llvm.wasm.memtag.insert">; - -def int_wasm_memtag_tagbits : - DefaultAttrsIntrinsic<[llvm_i32_ty], [llvm_i32_ty], [IntrNoMem], "llvm.wasm.memtag.tagbits">; - } // TargetPrefix = "wasm" diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 61bbcf67f1dbe..e2715343a92ee 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -13,22 +13,53 @@ multiclass MemoryTaggingOps { -let hasSideEffects = 1 in -defm MEMTAG_RANDOM_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src), +defm MEMTAG_STATUS_A#B: I<(outs rc:$statuscode), (ins i32imm:$tableidx), (outs), (ins i32imm:$tableidx), - [(set rc:$dst, - (int_wasm_memtag_random (i32 imm:$tableidx), rc:$src))], - "memtag.random\t$dst, $tableidx, $src", - "memtag.random\t$tableidx", + [(set rc:$statuscode, + (int_wasm_memtag_status (i32 imm:$tableidx)))], + "memtag.status\t$statuscode, $tableidx", + "memtag.status\t$tableidx", 0xfc20>; +defm MEMTAG_EXTRACT_A#B: I<(outs rc:$taggedval), (ins i32imm:$tableidx, rc:$ptr), + (outs), (ins i32imm:$tableidx), + [(set rc:$taggedval, + (int_wasm_memtag_extract (i32 imm:$tableidx), rc:$ptr))], + "memtag.extract\t$taggedval, $tableidx, $ptr", + "memtag.extract\t$tableidx", + 0xfc21>; + +defm MEMTAG_INSERT_A#B: I<(outs rc:$taggedptr), (ins i32imm:$tableidx, rc:$ptr, rc:$insertval), + (outs), (ins i32imm:$tableidx), + [(set rc:$taggedptr, + (int_wasm_memtag_insert (i32 imm:$tableidx), rc:$ptr, rc:$insertval))], + "memtag.insert\t$taggedptr, $tableidx, $ptr, $insertval", + "memtag.insert\t$tableidx", + 0xfc22>; + +defm MEMTAG_TAGBITS_A#B: I<(outs rc:$taggedbits), (ins i32imm:$tableidx), + (outs), (ins i32imm:$tableidx), + [(set rc:$taggedbits, + (int_wasm_memtag_tagbits (i32 imm:$tableidx)))], + "memtag.tagbits\t$taggedbits, $tableidx", + "memtag.tagbits\t$tableidx", + 0xfc23>; + +defm MEMTAG_STARTBIT_A#B: I<(outs rc:$startbit), (ins i32imm:$tableidx), + (outs), (ins i32imm:$tableidx), + [(set rc:$startbit, + (int_wasm_memtag_startbit (i32 imm:$tableidx)))], + "memtag.startbit\t$startbit, $tableidx", + "memtag.startbit\t$tableidx", + 0xfc24>; + defm MEMTAG_COPY_A#B: I<(outs rc:$dstwsrctag), (ins i32imm:$tableidx, rc:$dst, rc:$src), (outs), (ins i32imm:$tableidx), [(set rc:$dstwsrctag, (int_wasm_memtag_copy (i32 imm:$tableidx), rc:$dst, rc:$src))], "memtag.copy\t$dstwsrctag, $tableidx, $dst, $src", "memtag.copy\t$tableidx", - 0xfc21>; + 0xfc25>; defm MEMTAG_SUB_A#B: I<(outs rc:$diff), (ins i32imm:$tableidx, rc:$minuendptr, rc:$subtrahendptr), (outs), (ins i32imm:$tableidx), @@ -36,7 +67,7 @@ defm MEMTAG_SUB_A#B: I<(outs rc:$diff), (ins i32imm:$tableidx, rc:$minuendptr, r (int_wasm_memtag_sub (i32 imm:$tableidx), rc:$minuendptr, rc:$subtrahendptr))], "memtag.sub\t$diff, $tableidx, $minuendptr, $subtrahendptr", "memtag.sub\t$tableidx", - 0xfc22>; + 0xfc26>; let mayLoad = 1 in defm MEMTAG_LOAD_A#B: I<(outs rc:$taggedptr), (ins i32imm:$tableidx, rc:$src), @@ -45,7 +76,39 @@ defm MEMTAG_LOAD_A#B: I<(outs rc:$taggedptr), (ins i32imm:$tableidx, rc:$src), (int_wasm_memtag_load (i32 imm:$tableidx), rc:$src))], "memtag.load\t$taggedptr, $tableidx, $src", "memtag.load\t$tableidx", - 0xfc23>; + 0xfc27>; + +defm MEMTAG_UNTAG_A#B: I<(outs rc:$untaggedptr), (ins i32imm:$tableidx, rc:$ptr), + (outs), (ins i32imm:$tableidx), + [(set rc:$untaggedptr, + (int_wasm_memtag_untag (i32 imm:$tableidx), rc:$ptr))], + "memtag.untag\t$untaggedptr, $tableidx, $ptr", + "memtag.untag\t$tableidx", + 0xfc28>; + +let mayStore = 1 in +defm MEMTAG_UNTAGSTORE_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), + (outs), (ins i32imm:$tableidx), + [(int_wasm_memtag_store (i32 imm:$tableidx), rc:$src, rc:$b16)], + "memtag.untagstore\t$tableidx, $src, $b16", + "memtag.untagstore\t$tableidx", + 0xfc29>; + +let mayStore = 1 in +defm MEMTAG_UNTAGSTOREZ_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), + (outs), (ins i32imm:$tableidx), + [(int_wasm_memtag_storez (i32 imm:$tableidx), rc:$src, rc:$b16)], + "memtag.untagstorez\t$tableidx, $src, $b16", + "memtag.untagstorez\t$tableidx", + 0xfc2a>; + +let mayStore = 1 in +defm MEMTAG_STOREZ_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), + (outs), (ins i32imm:$tableidx), + [(int_wasm_memtag_storez (i32 imm:$tableidx), rc:$src, rc:$b16)], + "memtag.storez\t$tableidx, $src, $b16", + "memtag.storez\t$tableidx", + 0xfc2b>; let mayStore = 1 in defm MEMTAG_STORE_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), @@ -53,7 +116,7 @@ defm MEMTAG_STORE_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), [(int_wasm_memtag_store (i32 imm:$tableidx), rc:$src, rc:$b16)], "memtag.store\t$tableidx, $src, $b16", "memtag.store\t$tableidx", - 0xfc24>; + 0xfc2c>; let mayStore = 1 in defm MEMTAG_STOREZ_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), @@ -61,8 +124,16 @@ defm MEMTAG_STOREZ_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), [(int_wasm_memtag_storez (i32 imm:$tableidx), rc:$src, rc:$b16)], "memtag.storez\t$tableidx, $src, $b16", "memtag.storez\t$tableidx", - 0xfc25>; + 0xfc2d>; +let hasSideEffects = 1 in +defm MEMTAG_RANDOM_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memtag_random (i32 imm:$tableidx), rc:$src))], + "memtag.random\t$dst, $tableidx, $src", + "memtag.random\t$tableidx", + 0xfc2e>; let hasSideEffects = 1, mayStore = 1 in defm MEMTAG_RANDOMSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), @@ -71,7 +142,7 @@ defm MEMTAG_RANDOMSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, r (int_wasm_memtag_randomstore (i32 imm:$tableidx), rc:$src, rc:$b16))], "memtag.randomstore\t$dst, $tableidx, $src, $b16", "memtag.randomstore\t$tableidx", - 0xfc26>; + 0xfc2f>; let hasSideEffects = 1, mayStore = 1 in defm MEMTAG_RANDOMSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), @@ -80,7 +151,61 @@ defm MEMTAG_RANDOMSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, (int_wasm_memtag_randomstorez (i32 imm:$tableidx), rc:$src, rc:$b16))], "memtag.randomstorez\t$dst, $src, $tableidx, $b16", "memtag.randomstorez\t$tableidx", - 0xfc27>; + 0xfc30>; + +let hasSideEffects = 1 in +defm MEMTAG_RANDOMMASK_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$mask), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memtag_randommask (i32 imm:$tableidx), rc:$src, rc:$mask))], + "memtag.randommask\t$dst, $tableidx, $src, $mask", + "memtag.randommask\t$tableidx", + 0xfc31>; + + +let hasSideEffects = 1, mayStore = 1 in +defm MEMTAG_RANDOMMASKSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$mask), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memtag_randomstore (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$mask))], + "memtag.randommaskstore\t$dst, $tableidx, $src, $b16, $mask", + "memtag.randommaskstore\t$tableidx", + 0xfc32>; + +let hasSideEffects = 1, mayStore = 1 in +defm MEMTAG_RANDOMMASKSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$mask), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memtag_randommaskstorez (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$mask))], + "memtag.randommaskstorez\t$dst, $src, $tableidx, $b16, $mask", + "memtag.randommaskstorez\t$tableidx", + 0xfc33>; + +defm MEMTAG_ADD_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$addroffset, rc:$tagoffset), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memtag_add (i32 imm:$tableidx), rc:$src, rc:$addroffset, rc:$tagoffset))], + "memtag.add\t$dst, $tableidx, $src, $addroffset, $tagoffset", + "memtag.add\t$tableidx", + 0xfc34>; + +let mayStore = 1 in +defm MEMTAG_ADDSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addroffset, rc:$tagoffset), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memtag_addstore (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$addaddr, rc:$index))], + "memtag.addstore\t$dst, $tableidx, $src, $b16, $addaddr, $index", + "memtag.addstore\t$tableidx", + 0xfc35>; + +let mayStore = 1 in +defm MEMTAG_ADDSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addroffset, rc:$tagoffset), + (outs), (ins i32imm:$tableidx), + [(set rc:$dst, + (int_wasm_memtag_addstorez (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$addroffset, rc:$tagoffset))], + "memtag.addstorez\t$dst, $tableidx, $src, $b16, $addaddr, $tagoffset", + "memtag.addstorez\t$tableidx", + 0xfc36>; defm MEMTAG_HINT_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$hintaddr, rc:$index), (outs), (ins i32imm:$tableidx), @@ -88,7 +213,7 @@ defm MEMTAG_HINT_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$hint (int_wasm_memtag_hint (i32 imm:$tableidx), rc:$src, rc:$hintaddr, rc:$index))], "memtag.hint\t$dst, $tableidx, $src, $hintaddr, $index", "memtag.hint\t$tableidx", - 0xfc28>; + 0xfc37>; let mayStore = 1 in defm MEMTAG_HINTSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), @@ -97,7 +222,7 @@ defm MEMTAG_HINTSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc: (int_wasm_memtag_hintstore (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$hintaddr, rc:$index))], "memtag.hintstore\t$dst, $tableidx, $src, $b16, $hintaddr, $index", "memtag.hintstore\t$tableidx", - 0xfc29>; + 0xfc38>; let mayStore = 1 in defm MEMTAG_HINTSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), @@ -106,39 +231,7 @@ defm MEMTAG_HINTSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc (int_wasm_memtag_hintstorez (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$hintaddr, rc:$index))], "memtag.hintstorez\t$dst, $tableidx, $src, $b16, $hintaddr, $index", "memtag.hintstorez\t$tableidx", - 0xfc2a>; - -defm MEMTAG_CLEAR_A#B: I<(outs rc:$untaggedptr), (ins i32imm:$tableidx, rc:$ptr), - (outs), (ins i32imm:$tableidx), - [(set rc:$untaggedptr, - (int_wasm_memtag_clear (i32 imm:$tableidx), rc:$ptr))], - "memtag.cleartag\t$untaggedptr, $tableidx, $ptr", - "memtag.cleartag\t$tableidx", - 0xfc2b>; - -defm MEMTAG_EXTRACT_A#B: I<(outs rc:$taggedval), (ins i32imm:$tableidx, rc:$ptr), - (outs), (ins i32imm:$tableidx), - [(set rc:$taggedval, - (int_wasm_memtag_extract (i32 imm:$tableidx), rc:$ptr))], - "memtag.extract\t$taggedval, $tableidx, $ptr", - "memtag.extract\t$tableidx", - 0xfc2c>; - -defm MEMTAG_INSERT_A#B: I<(outs rc:$taggedptr), (ins i32imm:$tableidx, rc:$ptr, rc:$insertval), - (outs), (ins i32imm:$tableidx), - [(set rc:$taggedptr, - (int_wasm_memtag_insert (i32 imm:$tableidx), rc:$ptr, rc:$insertval))], - "memtag.insert\t$taggedptr, $tableidx, $ptr, $insertval", - "memtag.insert\t$tableidx", - 0xfc2d>; - -defm MEMTAG_TAGBITS_A#B: I<(outs i32:$taggedbits), (ins i32imm:$tableidx), - (outs), (ins i32imm:$tableidx), - [(set i32:$taggedbits, - (int_wasm_memtag_tagbits (i32 imm:$tableidx)))], - "memtag.tagbits\t$taggedbits, $tableidx", - "memtag.tagbits\t$tableidx", - 0xfc2e>; + 0xfc39>; } From 84d762c2a6bc8989e21613c7dafb17886ce62b32 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 2 Jun 2024 17:35:00 -0400 Subject: [PATCH 098/111] Fix mt instructions --- llvm/include/llvm/IR/IntrinsicsWebAssembly.td | 4 ++-- .../Target/WebAssembly/WebAssemblyInstrMemtag.td | 16 +++++++++------- 2 files changed, 11 insertions(+), 9 deletions(-) diff --git a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td index b8d65ee7f734f..26fae627988a0 100644 --- a/llvm/include/llvm/IR/IntrinsicsWebAssembly.td +++ b/llvm/include/llvm/IR/IntrinsicsWebAssembly.td @@ -416,10 +416,10 @@ def int_wasm_memtag_untag : DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty], [IntrNoMem], "llvm.wasm.memtag.untag">; def int_wasm_memtag_untagstore : - DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.untagstore">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.untagstore">; def int_wasm_memtag_untagstorez : - DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.untagstorez">; + DefaultAttrsIntrinsic<[llvm_ptr_ty], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.untagstorez">; def int_wasm_memtag_store : DefaultAttrsIntrinsic<[], [llvm_i32_ty, llvm_ptr_ty, llvm_anyint_ty], [IntrWriteMem], "llvm.wasm.memtag.store">; diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index e2715343a92ee..0d6e552da0c2a 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -87,17 +87,19 @@ defm MEMTAG_UNTAG_A#B: I<(outs rc:$untaggedptr), (ins i32imm:$tableidx, rc:$ptr) 0xfc28>; let mayStore = 1 in -defm MEMTAG_UNTAGSTORE_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), +defm MEMTAG_UNTAGSTOREZ_A#B: I<(outs rc:$untaggedptr), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), - [(int_wasm_memtag_store (i32 imm:$tableidx), rc:$src, rc:$b16)], - "memtag.untagstore\t$tableidx, $src, $b16", - "memtag.untagstore\t$tableidx", + [(set rc:$untaggedptr, + (int_wasm_memtag_untagstore (i32 imm:$tableidx), rc:$src, rc:$b16))], + "memtag.untagstorez\t$tableidx, $src, $b16", + "memtag.untagstorez\t$tableidx", 0xfc29>; let mayStore = 1 in -defm MEMTAG_UNTAGSTOREZ_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), +defm MEMTAG_UNTAGSTOREZ_A#B: I<(outs rc:$untaggedptr), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), - [(int_wasm_memtag_storez (i32 imm:$tableidx), rc:$src, rc:$b16)], + [(set rc:$untaggedptr, + (int_wasm_memtag_untagstorez (i32 imm:$tableidx), rc:$src, rc:$b16))], "memtag.untagstorez\t$tableidx, $src, $b16", "memtag.untagstorez\t$tableidx", 0xfc2a>; @@ -167,7 +169,7 @@ let hasSideEffects = 1, mayStore = 1 in defm MEMTAG_RANDOMMASKSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$mask), (outs), (ins i32imm:$tableidx), [(set rc:$dst, - (int_wasm_memtag_randomstore (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$mask))], + (int_wasm_memtag_randommaskstore (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$mask))], "memtag.randommaskstore\t$dst, $tableidx, $src, $b16, $mask", "memtag.randommaskstore\t$tableidx", 0xfc32>; From c3af10fea0856978ddafdef99a5fdb437bf6e4f2 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 2 Jun 2024 19:29:48 -0400 Subject: [PATCH 099/111] Fix wasm mt instructions definitions --- .../WebAssembly/WebAssemblyInstrMemtag.td | 44 ++++++++----------- 1 file changed, 18 insertions(+), 26 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td index 0d6e552da0c2a..e1c74b6bda351 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrMemtag.td @@ -87,7 +87,7 @@ defm MEMTAG_UNTAG_A#B: I<(outs rc:$untaggedptr), (ins i32imm:$tableidx, rc:$ptr) 0xfc28>; let mayStore = 1 in -defm MEMTAG_UNTAGSTOREZ_A#B: I<(outs rc:$untaggedptr), (ins i32imm:$tableidx, rc:$src, rc:$b16), +defm MEMTAG_UNTAGSTORE_A#B: I<(outs rc:$untaggedptr), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(set rc:$untaggedptr, (int_wasm_memtag_untagstore (i32 imm:$tableidx), rc:$src, rc:$b16))], @@ -104,21 +104,13 @@ defm MEMTAG_UNTAGSTOREZ_A#B: I<(outs rc:$untaggedptr), (ins i32imm:$tableidx, rc "memtag.untagstorez\t$tableidx", 0xfc2a>; -let mayStore = 1 in -defm MEMTAG_STOREZ_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), - (outs), (ins i32imm:$tableidx), - [(int_wasm_memtag_storez (i32 imm:$tableidx), rc:$src, rc:$b16)], - "memtag.storez\t$tableidx, $src, $b16", - "memtag.storez\t$tableidx", - 0xfc2b>; - let mayStore = 1 in defm MEMTAG_STORE_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), (outs), (ins i32imm:$tableidx), [(int_wasm_memtag_store (i32 imm:$tableidx), rc:$src, rc:$b16)], "memtag.store\t$tableidx, $src, $b16", "memtag.store\t$tableidx", - 0xfc2c>; + 0xfc2b>; let mayStore = 1 in defm MEMTAG_STOREZ_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), @@ -126,7 +118,7 @@ defm MEMTAG_STOREZ_A#B: I<(outs), (ins i32imm:$tableidx, rc:$src, rc:$b16), [(int_wasm_memtag_storez (i32 imm:$tableidx), rc:$src, rc:$b16)], "memtag.storez\t$tableidx, $src, $b16", "memtag.storez\t$tableidx", - 0xfc2d>; + 0xfc2c>; let hasSideEffects = 1 in defm MEMTAG_RANDOM_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src), @@ -135,7 +127,7 @@ defm MEMTAG_RANDOM_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src), (int_wasm_memtag_random (i32 imm:$tableidx), rc:$src))], "memtag.random\t$dst, $tableidx, $src", "memtag.random\t$tableidx", - 0xfc2e>; + 0xfc2d>; let hasSideEffects = 1, mayStore = 1 in defm MEMTAG_RANDOMSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), @@ -144,7 +136,7 @@ defm MEMTAG_RANDOMSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, r (int_wasm_memtag_randomstore (i32 imm:$tableidx), rc:$src, rc:$b16))], "memtag.randomstore\t$dst, $tableidx, $src, $b16", "memtag.randomstore\t$tableidx", - 0xfc2f>; + 0xfc2e>; let hasSideEffects = 1, mayStore = 1 in defm MEMTAG_RANDOMSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16), @@ -153,7 +145,7 @@ defm MEMTAG_RANDOMSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, (int_wasm_memtag_randomstorez (i32 imm:$tableidx), rc:$src, rc:$b16))], "memtag.randomstorez\t$dst, $src, $tableidx, $b16", "memtag.randomstorez\t$tableidx", - 0xfc30>; + 0xfc2f>; let hasSideEffects = 1 in defm MEMTAG_RANDOMMASK_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$mask), @@ -162,7 +154,7 @@ defm MEMTAG_RANDOMMASK_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc (int_wasm_memtag_randommask (i32 imm:$tableidx), rc:$src, rc:$mask))], "memtag.randommask\t$dst, $tableidx, $src, $mask", "memtag.randommask\t$tableidx", - 0xfc31>; + 0xfc30>; let hasSideEffects = 1, mayStore = 1 in @@ -172,7 +164,7 @@ defm MEMTAG_RANDOMMASKSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$sr (int_wasm_memtag_randommaskstore (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$mask))], "memtag.randommaskstore\t$dst, $tableidx, $src, $b16, $mask", "memtag.randommaskstore\t$tableidx", - 0xfc32>; + 0xfc31>; let hasSideEffects = 1, mayStore = 1 in defm MEMTAG_RANDOMMASKSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$mask), @@ -181,7 +173,7 @@ defm MEMTAG_RANDOMMASKSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$s (int_wasm_memtag_randommaskstorez (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$mask))], "memtag.randommaskstorez\t$dst, $src, $tableidx, $b16, $mask", "memtag.randommaskstorez\t$tableidx", - 0xfc33>; + 0xfc32>; defm MEMTAG_ADD_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$addroffset, rc:$tagoffset), (outs), (ins i32imm:$tableidx), @@ -189,25 +181,25 @@ defm MEMTAG_ADD_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$addro (int_wasm_memtag_add (i32 imm:$tableidx), rc:$src, rc:$addroffset, rc:$tagoffset))], "memtag.add\t$dst, $tableidx, $src, $addroffset, $tagoffset", "memtag.add\t$tableidx", - 0xfc34>; + 0xfc33>; let mayStore = 1 in defm MEMTAG_ADDSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addroffset, rc:$tagoffset), (outs), (ins i32imm:$tableidx), [(set rc:$dst, - (int_wasm_memtag_addstore (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$addaddr, rc:$index))], - "memtag.addstore\t$dst, $tableidx, $src, $b16, $addaddr, $index", + (int_wasm_memtag_addstore (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$addroffset, rc:$tagoffset))], + "memtag.addstore\t$dst, $tableidx, $src, $b16, $addroffset, $tagoffset", "memtag.addstore\t$tableidx", - 0xfc35>; + 0xfc34>; let mayStore = 1 in defm MEMTAG_ADDSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$addroffset, rc:$tagoffset), (outs), (ins i32imm:$tableidx), [(set rc:$dst, (int_wasm_memtag_addstorez (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$addroffset, rc:$tagoffset))], - "memtag.addstorez\t$dst, $tableidx, $src, $b16, $addaddr, $tagoffset", + "memtag.addstorez\t$dst, $tableidx, $src, $b16, $addroffset, $tagoffset", "memtag.addstorez\t$tableidx", - 0xfc36>; + 0xfc35>; defm MEMTAG_HINT_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$hintaddr, rc:$index), (outs), (ins i32imm:$tableidx), @@ -215,7 +207,7 @@ defm MEMTAG_HINT_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$hint (int_wasm_memtag_hint (i32 imm:$tableidx), rc:$src, rc:$hintaddr, rc:$index))], "memtag.hint\t$dst, $tableidx, $src, $hintaddr, $index", "memtag.hint\t$tableidx", - 0xfc37>; + 0xfc36>; let mayStore = 1 in defm MEMTAG_HINTSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), @@ -224,7 +216,7 @@ defm MEMTAG_HINTSTORE_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc: (int_wasm_memtag_hintstore (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$hintaddr, rc:$index))], "memtag.hintstore\t$dst, $tableidx, $src, $b16, $hintaddr, $index", "memtag.hintstore\t$tableidx", - 0xfc38>; + 0xfc37>; let mayStore = 1 in defm MEMTAG_HINTSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc:$b16, rc:$hintaddr, rc:$index), @@ -233,7 +225,7 @@ defm MEMTAG_HINTSTOREZ_A#B: I<(outs rc:$dst), (ins i32imm:$tableidx, rc:$src, rc (int_wasm_memtag_hintstorez (i32 imm:$tableidx), rc:$src, rc:$b16, rc:$hintaddr, rc:$index))], "memtag.hintstorez\t$dst, $tableidx, $src, $b16, $hintaddr, $index", "memtag.hintstorez\t$tableidx", - 0xfc39>; + 0xfc38>; } From dc893f872f57ca861db78dbde6c995766c0a37f0 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 2 Jun 2024 20:05:55 -0400 Subject: [PATCH 100/111] use code from aarch64 stack tagging --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index e86a2e2e971eb..775b7b0b0c789 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -182,7 +182,9 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { ConstantInt::get(IntPtrType, Tag)}); if (Info.AI->hasName()) TagPCall->setName(Info.AI->getName() + ".tag"); - Info.AI->replaceAllUsesWith(TagPCall); + Info.AI->replaceUsesWithIf(TagPCall, [&](const Use &U) { + return !memtag::isLifetimeIntrinsic(U.getUser()); + }); TagPCall->setOperand(1, Info.AI); IntrinsicInst *Start = Info.LifetimeStart[0]; uint64_t Size = From 51a1df2ee4458e02ca6229febadde1abcb8e5575 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sun, 2 Jun 2024 20:57:22 -0400 Subject: [PATCH 101/111] remove tracking --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 775b7b0b0c789..ced9bc4904665 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -151,7 +151,6 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { uint64_t NextTag = 0; for (auto &I : AllocasToInstrument) { memtag::AllocaInfo &Info = I.second; - TrackingVH OldAI = Info.AI; memtag::alignAndPadAlloca(Info, kTagGranuleSize); uint64_t Tag = NextTag; if (iswasm32) { @@ -227,10 +226,12 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { for (auto *II : Info.LifetimeEnd) II->eraseFromParent(); } - // Fixup debug intrinsics to point to the new alloca. - for (auto *DVI : Info.DbgVariableIntrinsics) - DVI->replaceVariableLocationOp(OldAI, Info.AI); + + memtag::annotateDebugRecords(Info, static_cast(Tag)); } + + for (auto *I : SInfo.UnrecognizedLifetimes) + I->eraseFromParent(); return true; } From 597637d40822d4a39a2379367440851239bba693 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Fri, 7 Jun 2024 21:40:50 -0400 Subject: [PATCH 102/111] builtin wasm mtg clang builtins parameters wrong --- clang/include/clang/Basic/BuiltinsWebAssembly.def | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/clang/include/clang/Basic/BuiltinsWebAssembly.def b/clang/include/clang/Basic/BuiltinsWebAssembly.def index bebf27a5a19f5..459dd1fdd603d 100644 --- a/clang/include/clang/Basic/BuiltinsWebAssembly.def +++ b/clang/include/clang/Basic/BuiltinsWebAssembly.def @@ -26,9 +26,9 @@ BUILTIN(__builtin_wasm_memory_size, "zIi", "n") BUILTIN(__builtin_wasm_memory_grow, "zIiz", "n") // Memory Tagging -BUILTIN(__builtin_wasm_memtag_status, "ziIi", "n") -BUILTIN(__builtin_wasm_memtag_tagbits, "ziIi", "n") -BUILTIN(__builtin_wasm_memtag_startbit, "ziIi", "n") +BUILTIN(__builtin_wasm_memtag_status, "zIi", "n") +BUILTIN(__builtin_wasm_memtag_tagbits, "zIi", "n") +BUILTIN(__builtin_wasm_memtag_startbit, "zIi", "n") BUILTIN(__builtin_wasm_memtag_extract, "zIiv*", "n") BUILTIN(__builtin_wasm_memtag_insert, "v*Iiv*z", "n") BUILTIN(__builtin_wasm_memtag_copy, "v*Iiv*v*", "n") From 37f52ae4d3b2e27e0b40a01fc19be005ce32f7bd Mon Sep 17 00:00:00 2001 From: trcrsired Date: Tue, 25 Jun 2024 21:09:36 -0400 Subject: [PATCH 103/111] remove builtin-memtag.c test --- clang/test/CodeGen/WebAssembly/builtins-memtag.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/clang/test/CodeGen/WebAssembly/builtins-memtag.c b/clang/test/CodeGen/WebAssembly/builtins-memtag.c index ed52d94478e8d..c4fc1ffcdb855 100644 --- a/clang/test/CodeGen/WebAssembly/builtins-memtag.c +++ b/clang/test/CodeGen/WebAssembly/builtins-memtag.c @@ -8,8 +8,8 @@ // CHECK-NEXT: [[TMP0:%.*]] = {{[^@]+}}call ptr @llvm.wasm.memory.randomtag(ptr [[INDEX:%.*]]) // CHECK-NEXT: ret ptr %0 // -void* test_builtin_wasm_memory_randomtag(void *p) { - return __builtin_wasm_memory_randomtag(p); +void* test_builtin_wasm_memtag_random(void *p) { + return __builtin_wasm_memtag_random(p); } // CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_copytag From 39bd43e9b5097307845e7dd4e6ad210504703178 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Tue, 25 Jun 2024 21:11:34 -0400 Subject: [PATCH 104/111] remove builtins-memtag test --- .../CodeGen/WebAssembly/builtins-memtag.c | 123 ------------------ 1 file changed, 123 deletions(-) delete mode 100644 clang/test/CodeGen/WebAssembly/builtins-memtag.c diff --git a/clang/test/CodeGen/WebAssembly/builtins-memtag.c b/clang/test/CodeGen/WebAssembly/builtins-memtag.c deleted file mode 100644 index c4fc1ffcdb855..0000000000000 --- a/clang/test/CodeGen/WebAssembly/builtins-memtag.c +++ /dev/null @@ -1,123 +0,0 @@ -// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature -// RUN: %clang_cc1 -triple wasm64 -fsanitize=memtag -target-feature +reference-types -disable-O0-optnone -O3 -emit-llvm %s -o - | opt -S -passes=mem2reg | FileCheck %s -// REQUIRES: webassembly-registered-target - -// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_randomtag -// CHECK-SAME: (ptr noundef readnone [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { -// CHECK-NEXT: entry: -// CHECK-NEXT: [[TMP0:%.*]] = {{[^@]+}}call ptr @llvm.wasm.memory.randomtag(ptr [[INDEX:%.*]]) -// CHECK-NEXT: ret ptr %0 -// -void* test_builtin_wasm_memtag_random(void *p) { - return __builtin_wasm_memtag_random(p); -} - -// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_copytag -// CHECK-SAME: (ptr noundef readnone [[INDEX:%.*]], ptr noundef readnone [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { -// CHECK-NEXT: entry: -// CHECK-NEXT: [[TMP0:%.*]] = {{[^@]+}}call ptr @llvm.wasm.memory.copytag(ptr [[INDEX:%.*]], ptr [[INDEX:%.*]]) -// CHECK-NEXT: ret ptr %0 -// -void* test_builtin_wasm_memory_copytag(void *p1, void *p2) { - return __builtin_wasm_memory_copytag(p1, p2); -} - -// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_subtag -// CHECK-SAME: (ptr noundef readnone [[INDEX:%.*]], ptr noundef readnone [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { -// CHECK-NEXT: entry: -// CHECK-NEXT: [[TMP0:%.*]] = {{[^@]+}}call i64 @llvm.wasm.memory.subtag.i64(ptr [[INDEX:%.*]], ptr [[INDEX:%.*]]) -// CHECK-NEXT: ret i64 %0 -// -__PTRDIFF_TYPE__ test_builtin_wasm_memory_subtag(void *p1, void *p2) { - return __builtin_wasm_memory_subtag(p1, p2); -} - -// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_loadtag -// CHECK-SAME: (ptr noundef readonly [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { -// CHECK-NEXT: entry: -// CHECK-NEXT: [[TMP0:%.*]] = {{[^@]+}}call ptr @llvm.wasm.memory.loadtag(ptr [[INDEX:%.*]]) -// CHECK-NEXT: ret ptr %0 -// -void* test_builtin_wasm_memory_loadtag(void *p) { - return __builtin_wasm_memory_loadtag(p); -} - -// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_storetag -// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { -// CHECK-NEXT: entry: -// CHECK-NEXT: {{[^@]+}}call void @llvm.wasm.memory.storetag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) -// CHECK-NEXT: ret void -// -void test_builtin_wasm_memory_storetag(void *p, __SIZE_TYPE__ b16) { - __builtin_wasm_memory_storetag(p, b16); -} - -// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_storeztag -// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { -// CHECK-NEXT: entry: -// CHECK-NEXT: {{[^@]+}}call void @llvm.wasm.memory.storeztag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) -// CHECK-NEXT: ret void -// -void test_builtin_wasm_memory_storeztag(void *p, __SIZE_TYPE__ b16) { - __builtin_wasm_memory_storeztag(p, b16); -} - -// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_store1tag -// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { -// CHECK-NEXT: entry: -// CHECK-NEXT: {{[^@]+}}call void @llvm.wasm.memory.store1tag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) -// CHECK-NEXT: ret void -// -void test_builtin_wasm_memory_store1tag(void *p, __SIZE_TYPE__ b16) { - __builtin_wasm_memory_store1tag(p, b16); -} - -// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_storez1tag -// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { -// CHECK-NEXT: entry: -// CHECK-NEXT: {{[^@]+}}call void @llvm.wasm.memory.storez1tag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) -// CHECK-NEXT: ret void -// -void test_builtin_wasm_memory_storez1tag(void *p, __SIZE_TYPE__ b16) { - __builtin_wasm_memory_storez1tag(p, b16); -} - -// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_randomstoretag -// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { -// CHECK-NEXT: entry: -// CHECK-NEXT: {{[^@]+}}call ptr @llvm.wasm.memory.randomstoretag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) -// CHECK-NEXT: ret ptr -// -void* test_builtin_wasm_memory_randomstoretag(void *p, __SIZE_TYPE__ b16) { - return __builtin_wasm_memory_randomstoretag(p, b16); -} - -// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_randomstoreztag -// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { -// CHECK-NEXT: entry: -// CHECK-NEXT: {{[^@]+}}call ptr @llvm.wasm.memory.randomstoreztag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) -// CHECK-NEXT: ret ptr -// -void* test_builtin_wasm_memory_randomstoreztag(void *p, __SIZE_TYPE__ b16) { - return __builtin_wasm_memory_randomstoreztag(p, b16); -} - -// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_randomstore1tag -// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { -// CHECK-NEXT: entry: -// CHECK-NEXT: {{[^@]+}}call ptr @llvm.wasm.memory.randomstore1tag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) -// CHECK-NEXT: ret ptr -// -void* test_builtin_wasm_memory_randomstore1tag(void *p, __SIZE_TYPE__ b16) { - return __builtin_wasm_memory_randomstore1tag(p, b16); -} - -// CHECK-LABEL: define {{[^@]+}}@test_builtin_wasm_memory_randomstorez1tag -// CHECK-SAME: (ptr noundef [[INDEX:%.*]], i64 noundef [[INDEX:%.*]]) #[[ATTR0:[0-9]+]] { -// CHECK-NEXT: entry: -// CHECK-NEXT: {{[^@]+}}call ptr @llvm.wasm.memory.randomstorez1tag.i64(ptr [[INDEX:%.*]], i64 [[INDEX:%.*]]) -// CHECK-NEXT: ret ptr -// -void* test_builtin_wasm_memory_randomstorez1tag(void *p, __SIZE_TYPE__ b16) { - return __builtin_wasm_memory_randomstorez1tag(p, b16); -} From 1b433248c839c2889174843351dd5cb07e497c1b Mon Sep 17 00:00:00 2001 From: trcrsired Date: Tue, 3 Sep 2024 12:21:37 -0400 Subject: [PATCH 105/111] Fix webassemblystacktagging break by the upstream --- .../Target/WebAssembly/WebAssemblyStackTagging.cpp | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index ced9bc4904665..27fe1a5213751 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "WebAssembly.h" #include "llvm/Analysis/AliasAnalysis.h" +#include "llvm/Analysis/OptimizationRemarkEmitter.h" #include "llvm/Analysis/PostDominators.h" #include "llvm/Analysis/StackSafetyAnalysis.h" #include "llvm/IR/Constants.h" @@ -15,6 +16,7 @@ #include "llvm/IR/InstIterator.h" #include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/IntrinsicsWebAssembly.h" +#include "llvm/IR/PassManager.h" #include "llvm/IR/ValueHandle.h" #include "llvm/InitializePasses.h" #include "llvm/Pass.h" @@ -55,6 +57,7 @@ struct WebAssemblyStackTagging : public FunctionPass { if (MergeInit) AU.addRequired(); #endif + AU.addRequired(); } #endif }; // end of struct Hello @@ -109,10 +112,13 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { F = &Fn; DL = &Fn.getParent()->getDataLayout(); + OptimizationRemarkEmitter &ORE = + getAnalysis().getORE(); + SSI = &getAnalysis().getResult(); - memtag::StackInfoBuilder SIB(SSI); + memtag::StackInfoBuilder SIB(SSI, "webassembly-stack-tagging"); for (Instruction &I : instructions(F)) - SIB.visit(I); + SIB.visit(ORE, I); memtag::StackInfo &SInfo = SIB.get(); std::unique_ptr DeleteDT; @@ -242,6 +248,7 @@ INITIALIZE_PASS_BEGIN(WebAssemblyStackTagging, DEBUG_TYPE, INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass) #endif INITIALIZE_PASS_DEPENDENCY(StackSafetyGlobalInfoWrapperPass) +INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass) INITIALIZE_PASS_END(WebAssemblyStackTagging, DEBUG_TYPE, "WebAssembly Stack Tagging", false, false) From 557e182856f577bc5e816a7943696da178af2e50 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Wed, 16 Oct 2024 19:30:39 -0400 Subject: [PATCH 106/111] Use getOrInsertDeclaration --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index 27fe1a5213751..ca6e34b7ae524 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -93,7 +93,7 @@ Instruction *WebAssemblyStackTagging::insertBaseTaggedPointer( assert(PrologueBB); IRBuilder<> IRB(&PrologueBB->front()); - Function *RdTag = Intrinsic::getDeclaration(F->getParent(), + Function *RdTag = Intrinsic::getOrInsertDeclaration(F->getParent(), Intrinsic::wasm_memtag_random); Instruction *Base = IRB.CreateCall(RdTag, {IRB.getInt32(0), @@ -168,7 +168,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { Type *Int32Type = IRB.getInt32Ty(); Type *Int64Type = IRB.getInt64Ty(); Type *IntPtrType = iswasm32 ? Int32Type : Int64Type; - Function *StoreTagDecl = Intrinsic::getDeclaration( + Function *StoreTagDecl = Intrinsic::getOrInsertDeclaration( F->getParent(), Intrinsic::wasm_memtag_store, {IntPtrType}); // Calls to functions that may return twice (e.g. setjmp) confuse the // postdominator analysis, and will leave us to keep memory tagged after @@ -180,7 +180,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { 3) && !SInfo.CallsReturnTwice; if (StandardLifetime) { - auto *HintTagDecl = Intrinsic::getDeclaration( + auto *HintTagDecl = Intrinsic::getOrInsertDeclaration( F->getParent(), Intrinsic::wasm_memtag_hint, {IntPtrType}); auto *TagPCall = IRB.CreateCall( HintTagDecl, {ConstantInt::get(Int32Type, 0), Info.AI, Base, @@ -211,7 +211,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { } } else { uint64_t Size = *Info.AI->getAllocationSize(*DL); - auto *HintStoreTagDecl = Intrinsic::getDeclaration( + auto *HintStoreTagDecl = Intrinsic::getOrInsertDeclaration( F->getParent(), Intrinsic::wasm_memtag_hintstore, {IntPtrType, IntPtrType}); auto *TagPCall = IRB.CreateCall(HintStoreTagDecl, From 01cb8560c2ffa743c5e4525091d36736fab15a59 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Tue, 11 Feb 2025 17:31:55 -0500 Subject: [PATCH 107/111] [WebAssembly] update for upstream commit 9fbd5fb [IR][NFC] Switch to use LifetimeIntrinsic --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index ca6e34b7ae524..ba03d9d703eda 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -188,7 +188,7 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { if (Info.AI->hasName()) TagPCall->setName(Info.AI->getName() + ".tag"); Info.AI->replaceUsesWithIf(TagPCall, [&](const Use &U) { - return !memtag::isLifetimeIntrinsic(U.getUser()); + return !isa(U.getUser()); }); TagPCall->setOperand(1, Info.AI); IntrinsicInst *Start = Info.LifetimeStart[0]; From a4aba48896ebbe044c2f8bd9db6b91fe6565927b Mon Sep 17 00:00:00 2001 From: trcrsired Date: Tue, 11 Feb 2025 17:39:23 -0500 Subject: [PATCH 108/111] [Unix] use upstream version of unix.h --- llvm/lib/Support/Unix/Unix.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/lib/Support/Unix/Unix.h b/llvm/lib/Support/Unix/Unix.h index ea83818855574..a1d44c69ab1ab 100644 --- a/llvm/lib/Support/Unix/Unix.h +++ b/llvm/lib/Support/Unix/Unix.h @@ -100,4 +100,4 @@ inline struct timeval toTimeVal(TimePoint TP) { } // namespace sys } // namespace llvm -#endif \ No newline at end of file +#endif From 5cacbaf48bd5708e632cd89270e3d926b643c9c3 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Thu, 24 Jul 2025 22:15:50 +0800 Subject: [PATCH 109/111] [WebAssembly] Remove handling for lifetimes b59aaf7da7a7121bf0263243fcec6a5fd6db1a2b removes non-alloca insts. --- llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp index ba03d9d703eda..950fffca571d4 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyStackTagging.cpp @@ -93,8 +93,8 @@ Instruction *WebAssemblyStackTagging::insertBaseTaggedPointer( assert(PrologueBB); IRBuilder<> IRB(&PrologueBB->front()); - Function *RdTag = Intrinsic::getOrInsertDeclaration(F->getParent(), - Intrinsic::wasm_memtag_random); + Function *RdTag = Intrinsic::getOrInsertDeclaration( + F->getParent(), Intrinsic::wasm_memtag_random); Instruction *Base = IRB.CreateCall(RdTag, {IRB.getInt32(0), ::llvm::ConstantPointerNull::get(IRB.getPtrTy())}); @@ -175,7 +175,6 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { // function return. Work around this by always untagging at every return // statement if return_twice functions are called. bool StandardLifetime = - SInfo.UnrecognizedLifetimes.empty() && memtag::isStandardLifetime(Info.LifetimeStart, Info.LifetimeEnd, DT, LI, 3) && !SInfo.CallsReturnTwice; @@ -236,8 +235,6 @@ bool WebAssemblyStackTagging::runOnFunction(Function &Fn) { memtag::annotateDebugRecords(Info, static_cast(Tag)); } - for (auto *I : SInfo.UnrecognizedLifetimes) - I->eraseFromParent(); return true; } From 8a788c0ebcb8d492bb3682db48a222802b871fdc Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 2 Aug 2025 18:19:01 +0800 Subject: [PATCH 110/111] [wasm] fix wasm sub target merging issue --- llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h | 8 -------- 1 file changed, 8 deletions(-) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h b/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h index 19d335b6052be..616b2423cfef3 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h +++ b/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h @@ -46,20 +46,12 @@ class WebAssemblySubtarget final : public WebAssemblyGenSubtargetInfo { bool HasExceptionHandling = false; bool HasExtendedConst = false; bool HasFP16 = false; - bool HasGC = false; bool HasMultiMemory = false; bool HasMultivalue = false; bool HasMutableGlobals = false; bool HasNontrappingFPToInt = false; bool HasReferenceTypes = false; -<<<<<<< HEAD -<<<<<<< HEAD bool HasMemtag = false; -======= - bool HasGC = false; ->>>>>>> parent/main -======= ->>>>>>> parent/main bool HasSignExt = false; bool HasTailCall = false; bool HasWideArithmetic = false; From d5000effbebb28c10e95281cbd6ef255eac53899 Mon Sep 17 00:00:00 2001 From: trcrsired Date: Sat, 2 Aug 2025 18:23:34 +0800 Subject: [PATCH 111/111] [wasm] HasGC merged missing --- llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h | 1 + 1 file changed, 1 insertion(+) diff --git a/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h b/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h index 616b2423cfef3..86d98f614f3f0 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h +++ b/llvm/lib/Target/WebAssembly/WebAssemblySubtarget.h @@ -46,6 +46,7 @@ class WebAssemblySubtarget final : public WebAssemblyGenSubtargetInfo { bool HasExceptionHandling = false; bool HasExtendedConst = false; bool HasFP16 = false; + bool HasGC = false; bool HasMultiMemory = false; bool HasMultivalue = false; bool HasMutableGlobals = false;