[dfsan] Introduce memory mapping for origin tracking

[stephan.yichao.zhao]

Summary

This is a part of https://reviews.llvm.org/D95835.

[morehouse]

compiler-rt/lib/dfsan/dfsan.h

84

const_cast

[stephan.yichao.zhao]

removed the unnecessary const_cast

[stephan.yichao.zhao]

compiler-rt/lib/dfsan/dfsan.h

84

changed the return value to be const dfsan_label*, so we do not need the cast.

[dmajor]

This commit broke the build on aarch64 because OriginAddr() isn't defined on that platform, could you please take a look?

[stephan.yichao.zhao]

Thank you for reporting this. Fixed: https://github.com/llvm/llvm-project/commit/083d45b21c1f7651345c1378b7d3302afe8f297a

compiler-rt/include/sanitizer/dfsan_interface.h

 #include <stdint.h>
 #include <sanitizer/common_interface_defs.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 typedef uint16_t dfsan_label;
+typedef uint32_t dfsan_origin;
 
 /// Stores information associated with a specific label identifier.  A label
 /// may be a base label created using dfsan_create_label, with associated
 /// text description and user data, or an automatically created union label,
 /// which represents the union of two label identifiers (which may themselves
 /// be base or union labels).
 struct dfsan_label_info {
   // Fields for union labels, set to 0 for base labels.

compiler-rt/lib/dfsan/dfsan.h

 #ifndef DFSAN_H
 #define DFSAN_H
 
 #include "sanitizer_common/sanitizer_internal_defs.h"
 
 #include "dfsan_flags.h"
 #include "dfsan_platform.h"
 
-using __sanitizer::uptr;
 using __sanitizer::u16;
+using __sanitizer::u32;
+using __sanitizer::uptr;
 
 // Copy declarations from public sanitizer/dfsan_interface.h header here.
 typedef u16 dfsan_label;
+typedef u32 dfsan_origin;
 
 struct dfsan_label_info {
   dfsan_label l1;
   dfsan_label l2;
   const char *desc;
   void *userdata;
 };
 

 inline dfsan_label *shadow_for(void *ptr) {
   return (dfsan_label *) ((((uptr) ptr) & ShadowMask()) << 1);
 }
 
 inline const dfsan_label *shadow_for(const void *ptr) {
   return shadow_for(const_cast<void *>(ptr));
 }
 
+inline uptr unaligned_origin_for(uptr ptr) {
+  return OriginAddr() + (ptr & ShadowMask());
+}
+
+inline dfsan_origin *origin_for(void *ptr) {
+  auto aligned_addr = unaligned_origin_for(reinterpret_cast<uptr>(ptr)) &
+                      ~(sizeof(dfsan_origin) - 1);
+  return reinterpret_cast<dfsan_origin *>(aligned_addr);
+}
+
+inline const dfsan_origin *origin_for(const void *ptr) {
+  return origin_for(const_cast<void *>(ptr));
+}
+
+inline bool is_shadow_addr_valid(uptr shadow_addr) {
+  return (uptr)shadow_addr >= ShadowAddr() && (uptr)shadow_addr < OriginAddr();
+}
+
+inline bool has_valid_shadow_addr(const void *ptr) {
+  const dfsan_label *ptr_s = shadow_for(ptr);
+  return is_shadow_addr_valid((uptr)ptr_s);
+}
+
 }  // namespace __dfsan
 
 #endif  // DFSAN_H

compiler-rt/lib/dfsan/dfsan.cpp

 // On Linux/x86_64, memory is laid out as follows:
 //
 // +--------------------+ 0x800000000000 (top of memory)
 // | application memory |
 // +--------------------+ 0x700000008000 (kAppAddr)
 // |                    |
 // |       unused       |
 // |                    |
-// +--------------------+ 0x200200000000 (kUnusedAddr)
+// +--------------------+ 0x300200000000 (kUnusedAddr)
 // |    union table     |
-// +--------------------+ 0x200000000000 (kUnionTableAddr)
+// +--------------------+ 0x300000000000 (kUnionTableAddr)
+// |       origin       |
+// +--------------------+ 0x200000000000 (kOriginAddr)
 // |   shadow memory    |
 // +--------------------+ 0x000000010000 (kShadowAddr)
 // | reserved by kernel |
 // +--------------------+ 0x000000000000
 //
 // To derive a shadow memory address from an application memory address,
 // bits 44-46 are cleared to bring the address into the range
 // [0x000000008000,0x100000000000).  Then the address is shifted left by 1 to

compiler-rt/lib/dfsan/dfsan_platform.h

 #ifndef DFSAN_PLATFORM_H
 #define DFSAN_PLATFORM_H
 
 namespace __dfsan {
 
 #if defined(__x86_64__)
 struct Mapping {
   static const uptr kShadowAddr = 0x10000;
-  static const uptr kUnionTableAddr = 0x200000000000;
+  static const uptr kOriginAddr = 0x200000000000;
+  static const uptr kUnionTableAddr = 0x300000000000;
   static const uptr kAppAddr = 0x700000008000;
   static const uptr kShadowMask = ~0x700000000000;
 };
 #elif defined(__mips64)
 struct Mapping {
   static const uptr kShadowAddr = 0x10000;
   static const uptr kUnionTableAddr = 0x2000000000;
   static const uptr kAppAddr = 0xF000008000;

 extern int vmaSize;
 # define DFSAN_RUNTIME_VMA 1
 #else
 # error "DFSan not supported for this platform!"
 #endif
 
 enum MappingType {
   MAPPING_SHADOW_ADDR,
+#if defined(__x86_64__)
+  MAPPING_ORIGIN_ADDR,
+#endif
   MAPPING_UNION_TABLE_ADDR,
   MAPPING_APP_ADDR,
   MAPPING_SHADOW_MASK
 };
 
 template<typename Mapping, int Type>
 uptr MappingImpl(void) {
   switch (Type) {
     case MAPPING_SHADOW_ADDR: return Mapping::kShadowAddr;
+#if defined(__x86_64__)
+    case MAPPING_ORIGIN_ADDR:
+      return Mapping::kOriginAddr;
+#endif
     case MAPPING_UNION_TABLE_ADDR: return Mapping::kUnionTableAddr;
     case MAPPING_APP_ADDR: return Mapping::kAppAddr;
     case MAPPING_SHADOW_MASK: return Mapping::kShadowMask;
   }
 }
 
 template<int Type>
 uptr MappingArchImpl(void) {

 #endif
 }
 
 ALWAYS_INLINE
 uptr ShadowAddr() {
   return MappingArchImpl<MAPPING_SHADOW_ADDR>();
 }
 
+#if defined(__x86_64__)
+ALWAYS_INLINE
+uptr OriginAddr() { return MappingArchImpl<MAPPING_ORIGIN_ADDR>(); }
+#endif
+
 ALWAYS_INLINE
 uptr UnionTableAddr() {
   return MappingArchImpl<MAPPING_UNION_TABLE_ADDR>();
 }
 
 ALWAYS_INLINE
 uptr AppAddr() {
   return MappingArchImpl<MAPPING_APP_ADDR>();