[EfficiencySanitizer] Adds shadow memory parameters for 40-bit virtual memory address.

[slthakur]

Summary

Adding 40-bit shadow memory parameters because MIPS64 uses 40-bit virtual memory addresses.

[bruening]

lib/Transforms/Instrumentation/EfficiencySanitizer.cpp

102

Style: { on prior line

[slthakur]

Removed default case for reporting error for unsupported architectures as this was causing failures on aarch64, powerpc64 build bots

[slthakur]

Enabled the instrumentation tests only for mips and x86.

[rengolin]

Can you elaborate why this patch is restricting AArch64?

[slthakur]

Theres no good reason for restricting architectures other than x86 and mips. Since the instrumentation tests are running cleanly without these shadow memory parameters, I am okay with removing the default case which is reporting the fatal error.

[slthakur]

Removed default case which was reporting fatal error on aarch64, powerpc64 etc.

[slthakur]

Using if ... else construct instead of switch case to avoid warning about unhandled enumeration values.

[slthakur]

Increased patch context.

[slthakur]

Ping?

[bruening]

I assume your ping is to rengolin as his request for changes is still there.

[slthakur]

@rengolin: Could you please find some time to review this?

[rengolin]

Sorry, I was out for more than a week. The patch looks ok now, assuming it still passes all tests on X86_64, AArch64 and MIPS64.

[slthakur]

Committed revision 283433

lib/Transforms/Instrumentation/EfficiencySanitizer.cpp

 // We need to specify the tool to the runtime earlier than
 // the ctor is called in some cases, so we set a global variable.
 static const char *const EsanWhichToolName = "__esan_which_tool";
 
 // We must keep these Shadow* constants consistent with the esan runtime.
 // FIXME: Try to place these shadow constants, the names of the __esan_*
 // interface functions, and the ToolType enum into a header shared between
 // llvm and compiler-rt.
-static const uint64_t ShadowMask = 0x00000fffffffffffull;
-static const uint64_t ShadowOffs[3] = { // Indexed by scale
-  0x0000130000000000ull,
-  0x0000220000000000ull,
-  0x0000440000000000ull,
-};
+struct ShadowMemoryParams {
+  uint64_t ShadowMask;
+  uint64_t ShadowOffs[3];
+} ShadowParams;
+
+static const ShadowMemoryParams ShadowParams47 = {
+    0x00000fffffffffffull,
+    {
+        0x0000130000000000ull, 0x0000220000000000ull, 0x0000440000000000ull,
+    }};
+
+static const ShadowMemoryParams ShadowParams40 = {
+    0x0fffffffffull,
+    {
+        0x1300000000ull, 0x2200000000ull, 0x4400000000ull,
+    }};
+
 // This array is indexed by the ToolType enum.
 static const int ShadowScale[] = {
   0, // ESAN_None.
   2, // ESAN_CacheFrag: 4B:1B, so 4 to 1 == >>2.
   6, // ESAN_WorkingSet: 64B:1B, so 64 to 1 == >>6.
 };
 
 // MaxStructCounterNameSize is a soft size limit to avoid insanely long
Function *EsanExit = checkSanitizerInterfaceFunction(
       M.getOrInsertFunction(EsanExitName, IRB_Dtor.getVoidTy(),
                             Int8PtrTy, nullptr));
   EsanExit->setLinkage(Function::ExternalLinkage);
   IRB_Dtor.CreateCall(EsanExit, {ToolInfoArg});
   appendToGlobalDtors(M, EsanDtorFunction, EsanCtorAndDtorPriority);
 }
 
 bool EfficiencySanitizer::initOnModule(Module &M) {
+
+  Triple TargetTriple(M.getTargetTriple());
+  if (TargetTriple.getArch() == Triple::mips64 || TargetTriple.getArch() == Triple::mips64el)
+    ShadowParams = ShadowParams40;
+  else
+    ShadowParams = ShadowParams47;
+
   Ctx = &M.getContext();
   const DataLayout &DL = M.getDataLayout();
   IRBuilder<> IRB(M.getContext());
   IntegerType *OrdTy = IRB.getInt32Ty();
   PointerType *Int8PtrTy = Type::getInt8PtrTy(*Ctx);
   IntptrTy = DL.getIntPtrType(M.getContext());
   // Create the variable passed to EsanInit and EsanExit.
   Constant *ToolInfoArg = createEsanInitToolInfoArg(M, DL);
new GlobalVariable(M, OrdTy, true,
                                       static_cast<int>(Options.ToolType)),
                      EsanWhichToolName);
 
   return true;
 }
 
 Value *EfficiencySanitizer::appToShadow(Value *Shadow, IRBuilder<> &IRB) {
   // Shadow = ((App & Mask) + Offs) >> Scale
-  Shadow = IRB.CreateAnd(Shadow, ConstantInt::get(IntptrTy, ShadowMask));
+  Shadow = IRB.CreateAnd(Shadow, ConstantInt::get(IntptrTy, ShadowParams.ShadowMask));
   uint64_t Offs;
   int Scale = ShadowScale[Options.ToolType];
   if (Scale <= 2)
-    Offs = ShadowOffs[Scale];
+    Offs = ShadowParams.ShadowOffs[Scale];
   else
-    Offs = ShadowOffs[0] << Scale;
+    Offs = ShadowParams.ShadowOffs[0] << Scale;
   Shadow = IRB.CreateAdd(Shadow, ConstantInt::get(IntptrTy, Offs));
   if (Scale > 0)
     Shadow = IRB.CreateLShr(Shadow, Scale);
   return Shadow;
 }
 
 bool EfficiencySanitizer::shouldIgnoreMemoryAccess(Instruction *I) {
   if (Options.ToolType == EfficiencySanitizerOptions::ESAN_CacheFrag) {