[asan] Added -inline-small-callbacks LLVM flag, which would force inline code for 8 and 16 byte data types when otherwise a callback would have been used.

[kstoimenov]

Summary

The reason to inline the 8 and 16 byte access checks is that the code for those is smaller than the 1, 2 and 4 byte checks. This allows to have a balanced, middle ground setting between size and speed.

[kcc]

What's the code size implications?

clang/test/CodeGen/asan-use-callbacks.cpp

15

As we introduce a difference in behavior for small and large accesses,
I would extend this test to have 1, 2, 4, and 16-byte accesses.

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

310

The flag semantics are weird. We first say "use callbacks", then we say "but not for small callbacks".
Perhaps, instead, introduce a flag asan-short-instrumentation-with-call-threshold
and when present use this flag for 8/16 instead of the asan-instrumentation-with-call-threshold?

1749

perhaps move this logic to where UseCalls is computed initially?
(see my other comment too)

1751

for single-statement if bodies this code base does not use {}

[vitalybuka]

clang/test/CodeGen/asan-use-callbacks.cpp

15

changes in llvm/lib should be tested in corresponding llvm/test, not clang/test

clang/test/CodeGen/asan-use-callbacks.cpp

 // RUN: %clang -target x86_64-linux-gnu -S -emit-llvm -fsanitize=address \
 // RUN:     -o - %s \
 // RUN:     | FileCheck %s --check-prefixes=CHECK-NO-OUTLINE
 // RUN: %clang -target x86_64-linux-gnu -S -emit-llvm -o - \
 // RUN:     -fsanitize=address %s -fsanitize-address-outline-instrumentation \
 // RUN:     | FileCheck %s --check-prefixes=CHECK-OUTLINE
+// RUN: %clang -target x86_64-linux-gnu -S -emit-llvm -o - \
+// RUN:     -fsanitize=address %s -fsanitize-address-outline-instrumentation \
+// RUN:     -mllvm -asan-inline-small-callbacks \
+// RUN:     | FileCheck %s --check-prefixes=CHECK-NO-OUTLINE
 
-// CHECK-NO-OUTLINE-NOT: call{{.*}}@__asan_load4
-// CHECK-OUTLINE: call{{.*}}@__asan_load4
+// CHECK-NO-OUTLINE-NOT: call{{.*}}@__asan_load8
+// CHECK-OUTLINE: call{{.*}}@__asan_load8
 
-int deref(int *p) {
+long deref(long *p) {
   return *p;
 }

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

static cl::opt<bool> ClInvalidPointerSub(
     cl::desc("Instrument - operations with pointer operands"), cl::Hidden,
     cl::init(false));
 
 static cl::opt<unsigned> ClRealignStack(
     "asan-realign-stack",
     cl::desc("Realign stack to the value of this flag (power of two)"),
     cl::Hidden, cl::init(32));
 
+static cl::opt<bool> ClInlineSmallCallbacks(
+    "asan-inline-small-callbacks",
+    cl::desc("Inline callbacks for 8 and 16 byte types."), cl::Hidden,
+    cl::init(false));
+
 static cl::opt<int> ClInstrumentationWithCallsThreshold(
     "asan-instrumentation-with-call-threshold",
     cl::desc(
         "If the function being instrumented contains more than "
         "this number of memory accesses, use callbacks instead of "
         "inline checks (-1 means never use callbacks)."),
     cl::Hidden, cl::init(7000));
 
if (TargetTriple.isAMDGPU()) {
     if (!InsertBefore)
       return;
   }
 
   IRBuilder<> IRB(InsertBefore);
   Value *AddrLong = IRB.CreatePointerCast(Addr, IntptrTy);
   size_t AccessSizeIndex = TypeSizeToSizeIndex(TypeSize);
 
+  if (ClInlineSmallCallbacks && AccessSizeIndex > 2) {
+    UseCalls = false;
+  }
+
   if (UseCalls) {
     if (Exp == 0)
       IRB.CreateCall(AsanMemoryAccessCallback[IsWrite][0][AccessSizeIndex],
                      AddrLong);
     else
       IRB.CreateCall(AsanMemoryAccessCallback[IsWrite][1][AccessSizeIndex],
                      {AddrLong, ConstantInt::get(IRB.getInt32Ty(), Exp)});
     return;