[WebAssembly][Sanitizer] WebAssembly Memory Tagging

clang/include/clang/Basic/BuiltinsWebAssembly.def

@@ -25,6 +25,33 @@
 BUILTIN(__builtin_wasm_memory_size, "zIi", "n")
 BUILTIN(__builtin_wasm_memory_grow, "zIiz", "n")
 
+// Memory Tagging
+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")
+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")
+
 // Thread-local storage
 TARGET_BUILTIN(__builtin_wasm_tls_size, "z", "nc", "bulk-memory")
 TARGET_BUILTIN(__builtin_wasm_tls_align, "z", "nc", "bulk-memory")

clang/lib/CodeGen/TargetBuiltins/WebAssembly.cpp

@@ -671,6 +671,194 @@ Value *CodeGenFunction::EmitWebAssemblyBuiltinExpr(unsigned BuiltinID,
 
     return Builder.CreateCall(Callee, {TableX, TableY, SrcIdx, DstIdx, NElems});
   }
+  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));
+    Value *Ptr0 = EmitScalarExpr(E->getArg(1));
+    Value *Ptr1 = EmitScalarExpr(E->getArg(2));
+    return Builder.CreateCall(Callee, {Index, Ptr0, Ptr1});
+  }
+  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_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_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_memtag_store, B16->getType());
+    return Builder.CreateCall(Callee, {Index, Ptr, B16});
+  }
+  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_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));
+    Value *B16 = EmitScalarExpr(E->getArg(2));
+    Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_randomstore, B16->getType());
+    return Builder.CreateCall(Callee, {Index, Ptr, B16});
+  }
+  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_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));
+    Value *HintPtr = EmitScalarExpr(E->getArg(2));
+    Value *HintIdx = EmitScalarExpr(E->getArg(3));
+    Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memtag_hint, HintIdx->getType());
+    return Builder.CreateCall(Callee, {Index, Ptr, HintPtr, HintIdx});
+  }
+  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_memtag_hintstore,
+      {B16->getType(), HintIdx->getType()});
+    return Builder.CreateCall(Callee, {Index, Ptr, B16, HintPtr, HintIdx});
+  }
+  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_memtag_hintstorez,
+      {B16->getType(), HintIdx->getType()});
+    return Builder.CreateCall(Callee, {Index, Ptr, B16, HintPtr, HintIdx});
+  }
   default:
     return nullptr;
   }

clang/lib/Driver/SanitizerArgs.cpp

@@ -1578,6 +1578,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);
 }

clang/lib/Driver/ToolChain.cpp

@@ -1635,7 +1635,7 @@ 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;
 }

clang/lib/Driver/ToolChains/CommonArgs.cpp

@@ -1752,16 +1752,21 @@ 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();

compiler-rt/lib/builtins/fp_compare_impl.inc

@@ -18,9 +18,15 @@ 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;
+#elif defined(__wasm64__)
+// GCC uses int as CMP_RESULT
+typedef int CMP_RESULT;
 #else
 // Otherwise the comparison functions return long.
 typedef long CMP_RESULT;

lldb/source/Host/CMakeLists.txt

@@ -115,12 +115,8 @@ else()
       linux/HostInfoLinux.cpp
       linux/LibcGlue.cpp
       linux/Support.cpp
+      android/HostInfoAndroid.cpp
       )
-    if (CMAKE_SYSTEM_NAME MATCHES "Android")
-      add_host_subdirectory(android
-        android/HostInfoAndroid.cpp
-        )
-    endif()
   elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
     add_host_subdirectory(freebsd
       freebsd/Host.cpp

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