[DFSan] Cleanup code for platforms other than Linux x86_64.

[browneee]

Summary

These other platforms are unsupported and untested.
They could be re-added later based on MSan code.

[browneee]

Fix build.

[browneee]

Remove unused runtime global variable.

compiler-rt/lib/dfsan/dfsan.cpp

 SANITIZER_INTERFACE_ATTRIBUTE THREADLOCAL u64
     __dfsan_retval_tls[kDFsanRetvalTlsSize / sizeof(u64)];
 SANITIZER_INTERFACE_ATTRIBUTE THREADLOCAL u32 __dfsan_retval_origin_tls;
 SANITIZER_INTERFACE_ATTRIBUTE THREADLOCAL u64
     __dfsan_arg_tls[kDFsanArgTlsSize / sizeof(u64)];
 SANITIZER_INTERFACE_ATTRIBUTE THREADLOCAL u32
     __dfsan_arg_origin_tls[kDFsanArgOriginTlsSize / sizeof(u32)];
 
-SANITIZER_INTERFACE_ATTRIBUTE uptr __dfsan_shadow_ptr_mask;
-
 // Instrumented code may set this value in terms of -dfsan-track-origins.
 // * undefined or 0: do not track origins.
 // * 1: track origins at memory store operations.
 // * 2: TODO: track origins at memory store operations and callsites.
 extern "C" SANITIZER_WEAK_ATTRIBUTE const int __dfsan_track_origins;
 
 int __dfsan_get_track_origins() {
   return &__dfsan_track_origins ? __dfsan_track_origins : 0;

 // +--------------------+ 0x000000010000
 // | reserved by kernel |
 // +--------------------+ 0x000000000000
 //
 // To derive a shadow memory address from an application memory address, bits
 // 45-46 are cleared to bring the address into the range
 // [0x100000008000,0x200000000000).  See the function shadow_for below.
 //
-// On Linux/MIPS64, memory is laid out as follows:
-//
-// +--------------------+ 0x10000000000 (top of memory)
-// | application memory |
-// +--------------------+ 0xF000008000 (kAppAddr)
-// |                    |
-// |       unused       |
-// |                    |
-// +--------------------+ 0x2000000000 (kUnusedAddr)
-// |   shadow memory    |
-// +--------------------+ 0x1000008000 (kShadowAddr)
-// |       unused       |
-// +--------------------+ 0x0000010000
-// | reserved by kernel |
-// +--------------------+ 0x0000000000
-
-// On Linux/AArch64 (39-bit VMA), memory is laid out as follow:
-//
-// +--------------------+ 0x8000000000 (top of memory)
-// | application memory |
-// +--------------------+ 0x7000008000 (kAppAddr)
-// |                    |
-// |       unused       |
-// |                    |
-// +--------------------+ 0x1000000000 (kUnusedAddr)
-// |   shadow memory    |
-// +--------------------+ 0x0000010000 (kShadowAddr)
-// | reserved by kernel |
-// +--------------------+ 0x0000000000
-
-// On Linux/AArch64 (42-bit VMA), memory is laid out as follow:
-//
-// +--------------------+ 0x40000000000 (top of memory)
-// | application memory |
-// +--------------------+ 0x3ff00008000 (kAppAddr)
-// |                    |
-// |       unused       |
-// |                    |
-// +--------------------+ 0x8000000000 (kUnusedAddr)
-// |   shadow memory    |
-// +--------------------+ 0x0000010000 (kShadowAddr)
-// | reserved by kernel |
-// +--------------------+ 0x0000000000
-
-// On Linux/AArch64 (48-bit VMA), memory is laid out as follow:
 //
-// +--------------------+ 0x1000000000000 (top of memory)
-// | application memory |
-// +--------------------+ 0xffff00008000 (kAppAddr)
-// |       unused       |
-// +--------------------+ 0xaaaab0000000 (top of PIE address)
-// | application PIE    |
-// +--------------------+ 0xaaaaa0000000 (top of PIE address)
-// |                    |
-// |       unused       |
-// |                    |
-// +--------------------+ 0x8000000000 (kUnusedAddr)
-// |   shadow memory    |
-// +--------------------+ 0x0000010000 (kShadowAddr)
-// | reserved by kernel |
-// +--------------------+ 0x0000000000
 
-#ifdef DFSAN_RUNTIME_VMA
-// Runtime detected VMA size.
-int __dfsan::vmaSize;
-#endif
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE
 dfsan_label __dfsan_union_load(const dfsan_label *ls, uptr n) {
   dfsan_label label = ls[0];
   for (uptr i = 1; i != n; ++i)
     label |= ls[i];
   return label;
 }
void dfsan_clear_thread_local_state() {
 
   if (__dfsan_get_track_origins()) {
     internal_memset(__dfsan_arg_origin_tls, 0, sizeof(__dfsan_arg_origin_tls));
     internal_memset(&__dfsan_retval_origin_tls, 0,
                     sizeof(__dfsan_retval_origin_tls));
   }
 }
 
-static void InitializePlatformEarly() {
-  AvoidCVE_2016_2143();
-#ifdef DFSAN_RUNTIME_VMA
-  __dfsan::vmaSize =
-    (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1);
-  if (__dfsan::vmaSize == 39 || __dfsan::vmaSize == 42 ||
-      __dfsan::vmaSize == 48) {
-    __dfsan_shadow_ptr_mask = ShadowMask();
-  } else {
-    Printf("FATAL: DataFlowSanitizer: unsupported VMA range\n");
-    Printf("FATAL: Found %d - Supported 39, 42, and 48\n", __dfsan::vmaSize);
-    Die();
-  }
-#endif
-}
-
 extern "C" void dfsan_flush() {
   if (!MmapFixedSuperNoReserve(ShadowAddr(), UnusedAddr() - ShadowAddr()))
     Die();
 }
 
 static void DFsanInit(int argc, char **argv, char **envp) {
   CHECK(!dfsan_init_is_running);
   if (dfsan_inited)
     return;
   dfsan_init_is_running = true;
   SanitizerToolName = "DataflowSanitizer";
 
-  InitializeFlags();
+  AvoidCVE_2016_2143();
 
-  ::InitializePlatformEarly();
+  InitializeFlags();
 
   dfsan_flush();
   if (common_flags()->use_madv_dontdump)
     DontDumpShadowMemory(ShadowAddr(), UnusedAddr() - ShadowAddr());
 
   // Protect the region of memory we don't use, to preserve the one-to-one
   // mapping from application to shadow memory. But if ASLR is disabled, Linux
   // will load our executable in the middle of our unused region. This mostly

compiler-rt/lib/dfsan/dfsan_platform.h

 #define DFSAN_PLATFORM_H
 
 #include "sanitizer_common/sanitizer_common.h"
 
 namespace __dfsan {
 
 using __sanitizer::uptr;
 
-#if defined(__x86_64__)
 struct Mapping {
   static const uptr kShadowAddr = 0x100000008000;
   static const uptr kOriginAddr = 0x200000008000;
   static const uptr kUnusedAddr = 0x300000000000;
   static const uptr kAppAddr = 0x700000008000;
   static const uptr kShadowMask = ~0x600000000000;
 };
-#elif defined(__mips64)
-struct Mapping {
-  static const uptr kShadowAddr = 0x1000008000;
-  static const uptr kUnusedAddr = 0x2000000000;
-  static const uptr kAppAddr = 0xF000008000;
-  static const uptr kShadowMask = ~0xE000000000;
-};
-#elif defined(__aarch64__)
-struct Mapping39 {
-  static const uptr kShadowAddr = 0x10000;
-  static const uptr kUnusedAddr = 0x1000000000;
-  static const uptr kAppAddr = 0x7000008000;
-  static const uptr kShadowMask = ~0x7800000000;
-};
-
-struct Mapping42 {
-  static const uptr kShadowAddr = 0x10000;
-  static const uptr kUnusedAddr = 0x8000000000;
-  static const uptr kAppAddr = 0x3ff00008000;
-  static const uptr kShadowMask = ~0x3c000000000;
-};
-
-struct Mapping48 {
-  static const uptr kShadowAddr = 0x10000;
-  static const uptr kUnusedAddr = 0x8000000000;
-  static const uptr kAppAddr = 0xffff00008000;
-  static const uptr kShadowMask = ~0xfffff0000000;
-};
-
-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_UNUSED_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_UNUSED_ADDR:
       return Mapping::kUnusedAddr;
     case MAPPING_APP_ADDR: return Mapping::kAppAddr;
     case MAPPING_SHADOW_MASK: return Mapping::kShadowMask;
   }
 }
 
 template<int Type>
 uptr MappingArchImpl(void) {
-#ifdef __aarch64__
-  switch (vmaSize) {
-    case 39: return MappingImpl<Mapping39, Type>();
-    case 42: return MappingImpl<Mapping42, Type>();
-    case 48: return MappingImpl<Mapping48, Type>();
-  }
-  DCHECK(0);
-  return 0;
-#else
   return MappingImpl<Mapping, Type>();
-#endif
 }
 
 ALWAYS_INLINE
 uptr ShadowAddr() {
   return MappingArchImpl<MAPPING_SHADOW_ADDR>();
 }
 
 ALWAYS_INLINE
 uptr OriginAddr() {
-#if defined(__x86_64__)
   return MappingArchImpl<MAPPING_ORIGIN_ADDR>();
-#else
-  return 0;
-#endif
 }
 
 ALWAYS_INLINE
 uptr UnusedAddr() { return MappingArchImpl<MAPPING_UNUSED_ADDR>(); }
 
 ALWAYS_INLINE
 uptr AppAddr() {
   return MappingArchImpl<MAPPING_APP_ADDR>();

llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

 
 static const Align MinOriginAlignment = Align(4);
 
 // The size of TLS variables. These constants must be kept in sync with the ones
 // in dfsan.cpp.
 static const unsigned ArgTLSSize = 800;
 static const unsigned RetvalTLSSize = 800;
 
-// External symbol to be used when generating the shadow address for
-// architectures with multiple VMAs. Instead of using a constant integer
-// the runtime will set the external mask based on the VMA range.
-const char DFSanExternShadowPtrMask[] = "__dfsan_shadow_ptr_mask";
-
 // The -dfsan-preserve-alignment flag controls whether this pass assumes that
 // alignment requirements provided by the input IR are correct.  For example,
 // if the input IR contains a load with alignment 8, this flag will cause
 // the shadow load to have alignment 16.  This flag is disabled by default as
 // we have unfortunately encountered too much code (including Clang itself;
 // see PR14291) which performs misaligned access.
 static cl::opt<bool> ClPreserveAlignment(
     "dfsan-preserve-alignment",
class DataFlowSanitizer {
   ConstantInt *ShadowPtrMask;
   ConstantInt *ShadowBase;
   ConstantInt *OriginBase;
   Constant *ArgTLS;
   ArrayType *ArgOriginTLSTy;
   Constant *ArgOriginTLS;
   Constant *RetvalTLS;
   Constant *RetvalOriginTLS;
-  Constant *ExternalShadowMask;
   FunctionType *DFSanUnionLoadFnTy;
   FunctionType *DFSanLoadLabelAndOriginFnTy;
   FunctionType *DFSanUnimplementedFnTy;
   FunctionType *DFSanSetLabelFnTy;
   FunctionType *DFSanNonzeroLabelFnTy;
   FunctionType *DFSanVarargWrapperFnTy;
   FunctionType *DFSanCmpCallbackFnTy;
   FunctionType *DFSanLoadStoreCallbackFnTy;
class DataFlowSanitizer {
   FunctionCallee DFSanMemOriginTransferFn;
   FunctionCallee DFSanMaybeStoreOriginFn;
   SmallPtrSet<Value *, 16> DFSanRuntimeFunctions;
   MDNode *ColdCallWeights;
   MDNode *OriginStoreWeights;
   DFSanABIList ABIList;
   DenseMap<Value *, Function *> UnwrappedFnMap;
   AttrBuilder ReadOnlyNoneAttrs;
-  bool DFSanRuntimeShadowMask = false;
 
   Value *getShadowOffset(Value *Addr, IRBuilder<> &IRB);
   Value *getShadowAddress(Value *Addr, Instruction *Pos);
   Value *getShadowAddress(Value *Addr, Instruction *Pos, Value *ShadowOffset);
   std::pair<Value *, Value *>
   getShadowOriginAddress(Value *Addr, Align InstAlignment, Instruction *Pos);
   bool isInstrumented(const Function *F);
   bool isInstrumented(const GlobalAlias *GA);

 Type *DataFlowSanitizer::getShadowTy(Value *V) {
   return getShadowTy(V->getType());
 }
 
 bool DataFlowSanitizer::init(Module &M) {
   Triple TargetTriple(M.getTargetTriple());
   const DataLayout &DL = M.getDataLayout();
 
+  if (TargetTriple.getOS() != Triple::Linux)
+    report_fatal_error("unsupported operating system");
+  if (TargetTriple.getArch() != Triple::x86_64)
+    report_fatal_error("unsupported architecture");
+
   Mod = &M;
   Ctx = &M.getContext();
   Int8Ptr = Type::getInt8PtrTy(*Ctx);
   OriginTy = IntegerType::get(*Ctx, OriginWidthBits);
   OriginPtrTy = PointerType::getUnqual(OriginTy);
   PrimitiveShadowTy = IntegerType::get(*Ctx, ShadowWidthBits);
   PrimitiveShadowPtrTy = PointerType::getUnqual(PrimitiveShadowTy);
   IntptrTy = DL.getIntPtrType(*Ctx);
   ZeroPrimitiveShadow = ConstantInt::getSigned(PrimitiveShadowTy, 0);
   ZeroOrigin = ConstantInt::getSigned(OriginTy, 0);
 
-  // TODO: these should be platform-specific and set in the switch-stmt below.
   ShadowBase = ConstantInt::get(IntptrTy, 0x100000008000LL);
   OriginBase = ConstantInt::get(IntptrTy, 0x200000008000LL);
-
-  switch (TargetTriple.getArch()) {
-  case Triple::x86_64:
-    ShadowPtrMask = ConstantInt::getSigned(IntptrTy, ~0x600000000000LL);
-    break;
-  case Triple::mips64:
-  case Triple::mips64el:
-    ShadowPtrMask = ConstantInt::getSigned(IntptrTy, ~0xE000000000LL);
-    break;
-  case Triple::aarch64:
-  case Triple::aarch64_be:
-    // AArch64 supports multiple VMAs and the shadow mask is set at runtime.
-    DFSanRuntimeShadowMask = true;
-    break;
-  default:
-    report_fatal_error("unsupported triple");
-  }
-
   Type *DFSanUnionLoadArgs[2] = {PrimitiveShadowPtrTy, IntptrTy};
   DFSanUnionLoadFnTy = FunctionType::get(PrimitiveShadowTy, DFSanUnionLoadArgs,
                                          /*isVarArg=*/false);
   Type *DFSanLoadLabelAndOriginArgs[2] = {Int8Ptr, IntptrTy};
   DFSanLoadLabelAndOriginFnTy =
       FunctionType::get(IntegerType::get(*Ctx, 64), DFSanLoadLabelAndOriginArgs,
                         /*isVarArg=*/false);
   DFSanUnimplementedFnTy = FunctionType::get(
(void)Mod->getOrInsertGlobal("__dfsan_track_origins", OriginTy, [&] {
     return new GlobalVariable(
         M, OriginTy, true, GlobalValue::WeakODRLinkage,
         ConstantInt::getSigned(OriginTy, shouldTrackOrigins()),
         "__dfsan_track_origins");
   });
 
   injectMetadataGlobals(M);
 
-  ExternalShadowMask =
-      Mod->getOrInsertGlobal(DFSanExternShadowPtrMask, IntptrTy);
-
   initializeCallbackFunctions(M);
   initializeRuntimeFunctions(M);
 
   std::vector<Function *> FnsToInstrument;
   SmallPtrSet<Function *, 2> FnsWithNativeABI;
   for (Function &F : M)
     if (!F.isIntrinsic() && !DFSanRuntimeFunctions.contains(&F))
       FnsToInstrument.push_back(&F);
void DFSanFunction::setShadow(Instruction *I, Value *Shadow) {
   assert(DFS.shouldTrackFieldsAndIndices() ||
          Shadow->getType() == DFS.PrimitiveShadowTy);
   ValShadowMap[I] = Shadow;
 }
 
 Value *DataFlowSanitizer::getShadowOffset(Value *Addr, IRBuilder<> &IRB) {
   // Returns Addr & shadow_mask
   assert(Addr != RetvalTLS && "Reinstrumenting?");
-  Value *ShadowPtrMaskValue;
-  if (DFSanRuntimeShadowMask)
-    ShadowPtrMaskValue = IRB.CreateLoad(IntptrTy, ExternalShadowMask);
-  else
-    ShadowPtrMaskValue = ShadowPtrMask;
   return IRB.CreateAnd(IRB.CreatePtrToInt(Addr, IntptrTy),
-                       IRB.CreatePtrToInt(ShadowPtrMaskValue, IntptrTy));
+                       IRB.CreatePtrToInt(ShadowPtrMask, IntptrTy));
 }
 
 std::pair<Value *, Value *>
 DataFlowSanitizer::getShadowOriginAddress(Value *Addr, Align InstAlignment,
                                           Instruction *Pos) {
   // Returns ((Addr & shadow_mask) + origin_base - shadow_base) & ~4UL
   IRBuilder<> IRB(Pos);
   Value *ShadowOffset = getShadowOffset(Addr, IRB);

llvm/test/Instrumentation/DataFlowSanitizer/basic.ll

 ; RUN: opt < %s -dfsan -S | FileCheck %s --check-prefixes=CHECK,CHECK_NO_ORIGIN -DSHADOW_MASK=-105553116266497   --dump-input-context=100
 ; RUN: opt < %s -dfsan -dfsan-track-origins=1  -S | FileCheck %s --check-prefixes=CHECK,CHECK_ORIGIN -DSHADOW_MASK=-105553116266497  --dump-input-context=100
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK: @__dfsan_arg_tls = external thread_local(initialexec) global [100 x i64]
 ; CHECK: @__dfsan_retval_tls = external thread_local(initialexec) global [100 x i64]
 ; CHECK: @__dfsan_arg_origin_tls = external thread_local(initialexec) global [200 x i32]
 ; CHECK: @__dfsan_retval_origin_tls = external thread_local(initialexec) global i32
 ; CHECK_NO_ORIGIN: @__dfsan_track_origins = weak_odr constant i32 0
 ; CHECK_ORIGIN: @__dfsan_track_origins = weak_odr constant i32 1
 ; CHECK: @__dfsan_shadow_width_bits = weak_odr constant i32 [[#SBITS:]]
 ; CHECK: @__dfsan_shadow_width_bytes = weak_odr constant i32 [[#SBYTES:]]
-; CHECK: @__dfsan_shadow_ptr_mask = external global i64
 
 define i8 @load(i8* %p) {
   ; CHECK-LABEL: define i8 @load.dfsan
   ; CHECK: and i64 {{.*}}, [[SHADOW_MASK]]
   ; CHECK: ret i8 %a
   %a = load i8, i8* %p
   ret i8 %a
 }

llvm/test/Instrumentation/DataFlowSanitizer/external_mask.ll

-; RUN: opt < %s -dfsan -S | FileCheck %s
-target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
-target triple = "aarch64-unknown-linux-gnu"
-
-define i32 @test(i32 %a, i32* nocapture readonly %b) #0 {
-  ; CHECK: @test.dfsan
-  ; CHECK: %[[RV:.*]] load{{.*}}__dfsan_shadow_ptr_mask
-  ; CHECK: ptrtoint i32* {{.*}} to i64
-  ; CHECK: and {{.*}}%[[RV:.*]]
-  %1 = load i32, i32* %b, align 4
-  %2 = add nsw i32 %1, %a
-  ret i32 %2
-}