[DFSan] Refactor dfsan_mem_shadow_transfer.

[morehouse]

compiler-rt/lib/dfsan/dfsan.h

51

[browneee]

Fix comment.

compiler-rt/lib/dfsan/dfsan.h

 dfsan_origin dfsan_read_origin_of_first_taint(const void *addr, uptr size);
 
 // Set the data within [addr, addr+size) with label and origin.
 void dfsan_set_label_origin(dfsan_label label, dfsan_origin origin, void *addr,
                             uptr size);
 
 // Copy or move the origins of the len bytes from src to dst.
 void dfsan_mem_origin_transfer(const void *dst, const void *src, uptr len);
+
+// Copy shadow bytes from src to dst.
+// Note this preserves distinct taint labls at specific offsets.
+void dfsan_mem_shadow_transfer(void *dst, const void *src, uptr len);
 }  // extern "C"
 
 template <typename T>
 void dfsan_set_label(dfsan_label label, T &data) {
   dfsan_set_label(label, (void *)&data, sizeof(T));
 }
 
 namespace __dfsan {

compiler-rt/lib/dfsan/dfsan.cpp

extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __dfsan_mem_origin_transfer(
     const void *dst, const void *src, uptr len) {
   if (src == dst)
     return;
   GET_CALLER_PC_BP;
   GET_STORE_STACK_TRACE_PC_BP(pc, bp);
   MoveOrigin(dst, src, len, &stack);
 }
 
-SANITIZER_INTERFACE_ATTRIBUTE void dfsan_mem_origin_transfer(const void *dst,
-                                                             const void *src,
-                                                             uptr len) {
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE void dfsan_mem_origin_transfer(
+    const void *dst, const void *src, uptr len) {
   __dfsan_mem_origin_transfer(dst, src, len);
 }
 
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE void dfsan_mem_shadow_transfer(
+    void *dst, const void *src, uptr len) {
+  internal_memcpy((void *)__dfsan::shadow_for(dst),
+                  (const void *)__dfsan::shadow_for(src),
+                  len * sizeof(dfsan_label));
+}
+
 namespace __dfsan {
 
 bool dfsan_inited = false;
 bool dfsan_init_is_running = false;
 
 void dfsan_copy_memory(void *dst, const void *src, uptr size) {
   internal_memcpy(dst, src, size);
-  internal_memcpy((void *)shadow_for(dst), (const void *)shadow_for(src),
-                  size * sizeof(dfsan_label));
+  dfsan_mem_shadow_transfer(dst, src, size);
   if (dfsan_get_track_origins())
     dfsan_mem_origin_transfer(dst, src, size);
 }
 
 // Releases the pages within the origin address range.
 static void ReleaseOrigins(void *addr, uptr size) {
   const uptr beg_origin_addr = (uptr)__dfsan::origin_for(addr);
   const void *end_addr = (void *)((uptr)addr + size);

compiler-rt/lib/dfsan/dfsan_custom.cpp

 }
 
 static void *dfsan_memmove_with_origin(void *dest, const void *src, size_t n) {
   dfsan_mem_origin_transfer(dest, src, n);
   return dfsan_memmove(dest, src, n);
 }
 
 static void *dfsan_memcpy(void *dest, const void *src, size_t n) {
-  dfsan_label *sdest = shadow_for(dest);
-  const dfsan_label *ssrc = shadow_for(src);
-  internal_memcpy((void *)sdest, (const void *)ssrc, n * sizeof(dfsan_label));
+  dfsan_mem_shadow_transfer(dest, src, n);
   return internal_memcpy(dest, src, n);
 }
 
 static void *dfsan_memcpy_with_origin(void *dest, const void *src, size_t n) {
   dfsan_mem_origin_transfer(dest, src, n);
   return dfsan_memcpy(dest, src, n);
 }
 

 }
 
 SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strcat(char *dest, const char *src,
                                                   dfsan_label dest_label,
                                                   dfsan_label src_label,
                                                   dfsan_label *ret_label) {
   size_t dest_len = strlen(dest);
   char *ret = strcat(dest, src);
-  dfsan_label *sdest = shadow_for(dest + dest_len);
-  const dfsan_label *ssrc = shadow_for(src);
-  internal_memcpy((void *)sdest, (const void *)ssrc,
-                  strlen(src) * sizeof(dfsan_label));
+  dfsan_mem_shadow_transfer(dest + dest_len, src, strlen(src));
   *ret_label = dest_label;
   return ret;
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE char *__dfso_strcat(
     char *dest, const char *src, dfsan_label dest_label, dfsan_label src_label,
     dfsan_label *ret_label, dfsan_origin dest_origin, dfsan_origin src_origin,
     dfsan_origin *ret_origin) {
   size_t dest_len = strlen(dest);
   char *ret = strcat(dest, src);
-  dfsan_label *sdest = shadow_for(dest + dest_len);
-  const dfsan_label *ssrc = shadow_for(src);
   size_t src_len = strlen(src);
   dfsan_mem_origin_transfer(dest + dest_len, src, src_len);
-  internal_memcpy((void *)sdest, (const void *)ssrc,
-                  src_len * sizeof(dfsan_label));
+  dfsan_mem_shadow_transfer(dest + dest_len, src, src_len);
   *ret_label = dest_label;
   *ret_origin = dest_origin;
   return ret;
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE char *
 __dfsw_strdup(const char *s, dfsan_label s_label, dfsan_label *ret_label) {
   size_t len = strlen(s);
int __dfso_getrusage(int who, struct rusage *usage, dfsan_label who_label,
   return __dfsw_getrusage(who, usage, who_label, usage_label, ret_label);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 char *__dfsw_strcpy(char *dest, const char *src, dfsan_label dst_label,
                     dfsan_label src_label, dfsan_label *ret_label) {
   char *ret = strcpy(dest, src);
   if (ret) {
-    internal_memcpy(shadow_for(dest), shadow_for(src),
-                    sizeof(dfsan_label) * (strlen(src) + 1));
+    dfsan_mem_shadow_transfer(dest, src, strlen(src) + 1);
   }
   *ret_label = dst_label;
   return ret;
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 char *__dfso_strcpy(char *dest, const char *src, dfsan_label dst_label,
                     dfsan_label src_label, dfsan_label *ret_label,
                     dfsan_origin dst_origin, dfsan_origin src_origin,
                     dfsan_origin *ret_origin) {
   char *ret = strcpy(dest, src);
   if (ret) {
     size_t str_len = strlen(src) + 1;
     dfsan_mem_origin_transfer(dest, src, str_len);
-    internal_memcpy(shadow_for(dest), shadow_for(src),
-                    sizeof(dfsan_label) * str_len);
+    dfsan_mem_shadow_transfer(dest, src, str_len);
   }
   *ret_label = dst_label;
   *ret_origin = dst_origin;
   return ret;
 }
 
 static long int dfsan_strtol(const char *nptr, char **endptr, int base,
                              char **tmp_endptr) {
if (*formatter.fmt_cur != '%') {
           char *arg = va_arg(ap, char *);
           retval = formatter.format(arg);
           if (va_origins) {
             va_origins++;
             dfsan_mem_origin_transfer(formatter.str_cur(), arg,
                                       formatter.num_written_bytes(retval));
           }
           va_labels++;
-          internal_memcpy(shadow_for(formatter.str_cur()), shadow_for(arg),
-                          sizeof(dfsan_label) *
+          dfsan_mem_shadow_transfer(formatter.str_cur(), arg,
                                     formatter.num_written_bytes(retval));
           end_fmt = true;
           break;
         }
 
         case 'p':
           retval = formatter.format(va_arg(ap, void *));
           if (va_origins == nullptr)
             dfsan_set_label(*va_labels++, formatter.str_cur(),