Implement Pragma() for Reactor MemorySanitizer instrumentation

src/Android.bp

@@ -206,6 +206,7 @@ cc_defaults {
         "Reactor/LLVMJIT.cpp",
         "Reactor/LLVMReactor.cpp",
         "Reactor/OptimalIntrinsics.cpp",
+        "Reactor/Pragma.cpp",
         "Reactor/Reactor.cpp",
     ],
 

src/Reactor/BUILD.gn

@@ -49,6 +49,7 @@ swiftshader_source_set("swiftshader_reactor_base") {
     "EmulatedIntrinsics.cpp",
     "ExecutableMemory.cpp",
     "OptimalIntrinsics.cpp",
+    "Pragma.cpp",
     "Reactor.cpp",
   ]
 

src/Reactor/CMakeLists.txt

@@ -27,6 +27,9 @@ set(REACTOR_SRC_FILES
     Nucleus.hpp
     OptimalIntrinsics.cpp
     OptimalIntrinsics.hpp
+    Pragma.cpp
+    Pragma.hpp
+    PragmaInternals.hpp
     Print.hpp
     Reactor.cpp
     Reactor.hpp

src/Reactor/LLVMJIT.cpp

@@ -17,6 +17,7 @@
 #include "Debug.hpp"
 #include "ExecutableMemory.hpp"
 #include "LLVMAsm.hpp"
+#include "PragmaInternals.hpp"
 #include "Routine.hpp"
 
 // TODO(b/143539525): Eliminate when warning has been fixed.
@@ -823,7 +824,8 @@ JITBuilder::JITBuilder(const rr::Config &config)
 	module->setTargetTriple(LLVM_DEFAULT_TARGET_TRIPLE);
 	module->setDataLayout(JITGlobals::get()->getDataLayout());
 
-	if(REACTOR_ENABLE_MEMORY_SANITIZER_INSTRUMENTATION)
+	if(REACTOR_ENABLE_MEMORY_SANITIZER_INSTRUMENTATION ||
+	   getPragmaState(MemorySanitizerInstrumentation))
 	{
 		msanInstrumentation = true;
 	}

src/Reactor/Pragma.cpp

+// Copyright 2021 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Pragma.hpp"
+#include "PragmaInternals.hpp"
+
+#include "Debug.hpp"
+
+namespace rr {
+
+static thread_local bool memorySanitizerInstrumentation = false;
+
+void Pragma(PragmaBooleanOption option, bool enable)
+{
+	switch(option)
+	{
+	case MemorySanitizerInstrumentation:
+		memorySanitizerInstrumentation = enable;
+		break;
+	default:
+		UNSUPPORTED("Unknown pragma %d", int(option));
+	}
+}
+
+bool getPragmaState(PragmaBooleanOption option)
+{
+	switch(option)
+	{
+	case MemorySanitizerInstrumentation:
+		return memorySanitizerInstrumentation;
+	default:
+		UNSUPPORTED("Unknown pragma %d", int(option));
+		return false;
+	}
+}
+
+}  // namespace rr
\ No newline at end of file

src/Reactor/Pragma.hpp

+// Copyright 2021 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef rr_Pragma_hpp
+#define rr_Pragma_hpp
+
+namespace rr {
+
+enum PragmaBooleanOption
+{
+	MemorySanitizerInstrumentation,
+};
+
+void Pragma(PragmaBooleanOption option, bool enable);
+
+}  // namespace rr
+
+#endif  // rr_Pragma_hpp
\ No newline at end of file

src/Reactor/PragmaInternals.hpp

+// Copyright 2021 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef rr_PragmaInternals_hpp
+#define rr_PragmaInternals_hpp
+
+#include "Pragma.hpp"
+
+namespace rr {
+
+bool getPragmaState(PragmaBooleanOption option);
+
+}  // namespace rr
+
+#endif  // rr_Pragma_hpp
\ No newline at end of file

src/Reactor/Reactor.hpp

@@ -16,6 +16,7 @@
 #define rr_Reactor_hpp
 
 #include "Nucleus.hpp"
+#include "Pragma.hpp"
 #include "Routine.hpp"
 #include "Traits.hpp"
 

tests/ReactorUnitTests/ReactorUnitTests.cpp

@@ -136,9 +136,16 @@ TEST(ReactorUnitTests, Trampoline)
 	EXPECT_EQ(result, 80);
 }
 
-#if REACTOR_ENABLE_MEMORY_SANITIZER_INSTRUMENTATION
 TEST(ReactorUnitTests, Uninitialized)
 {
+#if __has_feature(memory_sanitizer)
+	// Building the static C++ code with MemorySanitizer enabled does not
+	// automatically enable MemorySanitizer instrumentation for Reactor
+	// routines. False positives can also be prevented by unpoisoning all
+	// memory writes. This Pragma ensures proper instrumentation is enabled.
+	Pragma(MemorySanitizerInstrumentation, true);
+#endif
+
 	FunctionT<int()> function;
 	{
 		Int a;
@@ -178,8 +185,9 @@ TEST(ReactorUnitTests, Uninitialized)
 		    },
 		    "MemorySanitizer: use-of-uninitialized-value");
 	}
+
+	Pragma(MemorySanitizerInstrumentation, false);
 }
-#endif
 
 TEST(ReactorUnitTests, Unreachable)
 {