[compiler-rt] 46fe36a - Revert "[compiler-rt] Remove duplicates of sanitizer_common functions"

[Alex Richardson via llvm-commits]

Author: Alex Richardson
Date: 2024-08-29T17:29:01-07:00
New Revision: 46fe36a4295f05d5d3731762e31fc4e6e99863e9

URL: https://github.com/llvm/llvm-project/commit/46fe36a4295f05d5d3731762e31fc4e6e99863e9
DIFF: https://github.com/llvm/llvm-project/commit/46fe36a4295f05d5d3731762e31fc4e6e99863e9.diff

LOG: Revert "[compiler-rt] Remove duplicates of sanitizer_common functions"

This works for MinGW, but the MSVC linker apparently doens't pull in
those symbols. Reverting for now since I won't be able to reproduce it today.

https://lab.llvm.org/buildbot/#/builders/107/builds/2337

This reverts commit 9df92cbd1addb03c7169f05cf3b628f88c610224.

Added: 
    

Modified: 
    compiler-rt/lib/interception/interception_win.cpp

Removed: 
    


################################################################################
diff  --git a/compiler-rt/lib/interception/interception_win.cpp b/compiler-rt/lib/interception/interception_win.cpp
index 0a9f2b62a78a58..a638e66eccee58 100644
--- a/compiler-rt/lib/interception/interception_win.cpp
+++ b/compiler-rt/lib/interception/interception_win.cpp
@@ -127,11 +127,9 @@
 #include "interception.h"
 
 #if SANITIZER_WINDOWS
-#  include "sanitizer_common/sanitizer_common.h"
-#  include "sanitizer_common/sanitizer_libc.h"
-#  include "sanitizer_common/sanitizer_platform.h"
-#  define WIN32_LEAN_AND_MEAN
-#  include <windows.h>
+#include "sanitizer_common/sanitizer_platform.h"
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
 
 namespace __interception {
 
@@ -188,6 +186,40 @@ static uptr GetMmapGranularity() {
   return si.dwAllocationGranularity;
 }
 
+UNUSED static uptr RoundUpTo(uptr size, uptr boundary) {
+  return (size + boundary - 1) & ~(boundary - 1);
+}
+
+// FIXME: internal_str* and internal_mem* functions should be moved from the
+// ASan sources into interception/.
+
+static size_t _strlen(const char *str) {
+  const char* p = str;
+  while (*p != '\0') ++p;
+  return p - str;
+}
+
+static char* _strchr(char* str, char c) {
+  while (*str) {
+    if (*str == c)
+      return str;
+    ++str;
+  }
+  return nullptr;
+}
+
+static void _memset(void *p, int value, size_t sz) {
+  for (size_t i = 0; i < sz; ++i)
+    ((char*)p)[i] = (char)value;
+}
+
+static void _memcpy(void *dst, void *src, size_t sz) {
+  char *dst_c = (char*)dst,
+       *src_c = (char*)src;
+  for (size_t i = 0; i < sz; ++i)
+    dst_c[i] = src_c[i];
+}
+
 static bool ChangeMemoryProtection(
     uptr address, uptr size, DWORD *old_protection) {
   return ::VirtualProtect((void*)address, size,
@@ -234,7 +266,7 @@ static bool FunctionHasPadding(uptr address, uptr size) {
 }
 
 static void WritePadding(uptr from, uptr size) {
-  internal_memset((void *)from, 0xCC, (size_t)size);
+  _memset((void*)from, 0xCC, (size_t)size);
 }
 
 static void WriteJumpInstruction(uptr from, uptr target) {
@@ -705,8 +737,8 @@ static bool CopyInstructions(uptr to, uptr from, size_t size) {
     size_t instruction_size = GetInstructionSize(from + cursor, &rel_offset);
     if (!instruction_size)
       return false;
-    internal_memcpy((void *)(to + cursor), (void *)(from + cursor),
-                    (size_t)instruction_size);
+    _memcpy((void *)(to + cursor), (void *)(from + cursor),
+            (size_t)instruction_size);
     if (rel_offset) {
 #  if SANITIZER_WINDOWS64
       // we want to make sure that the new relative offset still fits in 32-bits
@@ -995,7 +1027,7 @@ uptr InternalGetProcAddress(void *module, const char *func_name) {
 
   for (DWORD i = 0; i < exports->NumberOfNames; i++) {
     RVAPtr<char> name(module, names[i]);
-    if (!internal_strcmp(func_name, name)) {
+    if (!strcmp(func_name, name)) {
       DWORD index = ordinals[i];
       RVAPtr<char> func(module, functions[index]);
 
@@ -1007,13 +1039,13 @@ uptr InternalGetProcAddress(void *module, const char *func_name) {
         // format: "<module> . <function_name>" that is stored into the
         // exported directory.
         char function_name[256];
-        size_t funtion_name_length = internal_strlen(func);
+        size_t funtion_name_length = _strlen(func);
         if (funtion_name_length >= sizeof(function_name) - 1)
           InterceptionFailed();
 
-        internal_memcpy(function_name, func, funtion_name_length);
+        _memcpy(function_name, func, funtion_name_length);
         function_name[funtion_name_length] = '\0';
-        char *separator = internal_strchr(function_name, '.');
+        char* separator = _strchr(function_name, '.');
         if (!separator)
           InterceptionFailed();
         *separator = '\0';