[DFSan] Handle fast16labels for all API functions.

[morehouse]

Summary

Support fast16labels in dfsan_has_label, and print an error for all
other API functions.

[kcc]

I think this is an overkill.
fast16labels mode should be even simpler:
there are always 16 primary labels, they don't have any descriptions or properties controlled by dfsan.

compiler-rt/lib/dfsan/dfsan.cpp

267

I would just err in fast16labels mode w/i checking for last_lavel > 15.
Users should not call this function at all in fast16labels mode, IMO.

322

same

343

same

369

same

[morehouse]

In D84215#2164676, @kcc wrote:

I think this is an overkill.
fast16labels mode should be even simpler:
there are always 16 primary labels, they don't have any descriptions or properties controlled by dfsan.

Seems reasonable, but note it will require effort for existing API users to switch. For example, all the existing protobuf labeling API, etc. will need to be adapted.

[kcc]

and that's fine. I want this mode to be as simple as possible.

[kcc]

Also, we don't have to err in these functions at all, it's fine to just return silently.

[morehouse]

• Print error on most API calls under fast16labels mode.

[morehouse]

• Update diffbase.

[kcc]

LGTM

compiler-rt/lib/dfsan/dfsan.cpp

 // Checks we do not run out of labels.
 static void dfsan_check_label(dfsan_label label) {
   if (label == kInitializingLabel) {
     Report("FATAL: DataFlowSanitizer: out of labels\n");
     Die();
   }
 }
 
+static void ReportUnsupportedFast16(const char *func) {
+  Report("FATAL: DataFlowSanitizer: %s is unsupported in fast16labels mode\n",
+         func);
+  Die();
+}
+
 // Resolves the union of two unequal labels.  Nonequality is a precondition for
 // this function (the instrumentation pass inlines the equality test).
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE
 dfsan_label __dfsan_union(dfsan_label l1, dfsan_label l2) {
   if (flags().fast16labels)
     return l1 | l2;
   DCHECK_NE(l1, l2);
 

 dfsan_union(dfsan_label l1, dfsan_label l2) {
   if (l1 == l2)
     return l1;
   return __dfsan_union(l1, l2);
 }
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE
 dfsan_label dfsan_create_label(const char *desc, void *userdata) {
+  if (flags().fast16labels)
+    ReportUnsupportedFast16("dfsan_create_label");
   dfsan_label label =
       atomic_fetch_add(&__dfsan_last_label, 1, memory_order_relaxed) + 1;
   dfsan_check_label(label);
   __dfsan_label_info[label].l1 = __dfsan_label_info[label].l2 = 0;
   __dfsan_label_info[label].desc = desc;
   __dfsan_label_info[label].userdata = userdata;
   return label;
 }
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE
 void __dfsan_set_label(dfsan_label label, void *addr, uptr size) {
   for (dfsan_label *labelp = shadow_for(addr); size != 0; --size, ++labelp) {

 dfsan_read_label(const void *addr, uptr size) {
   if (size == 0)
     return 0;
   return __dfsan_union_load(shadow_for(addr), size);
 }
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE
 const struct dfsan_label_info *dfsan_get_label_info(dfsan_label label) {
+  if (flags().fast16labels)
+    ReportUnsupportedFast16("dfsan_get_label_info");
   return &__dfsan_label_info[label];
 }
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE int
 dfsan_has_label(dfsan_label label, dfsan_label elem) {
+  if (flags().fast16labels)
+    return label & elem;
   if (label == elem)
     return true;
   const dfsan_label_info *info = dfsan_get_label_info(label);
   if (info->l1 != 0) {
     return dfsan_has_label(info->l1, elem) || dfsan_has_label(info->l2, elem);
   } else {
     return false;
   }
 }
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE dfsan_label
 dfsan_has_label_with_desc(dfsan_label label, const char *desc) {
+  if (flags().fast16labels)
+    ReportUnsupportedFast16("dfsan_has_label_with_desc");
   const dfsan_label_info *info = dfsan_get_label_info(label);
   if (info->l1 != 0) {
     return dfsan_has_label_with_desc(info->l1, desc) ||
            dfsan_has_label_with_desc(info->l2, desc);
   } else {
     return internal_strcmp(desc, info->desc) == 0;
   }
 }
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE uptr
 dfsan_get_label_count(void) {
   dfsan_label max_label_allocated =
       atomic_load(&__dfsan_last_label, memory_order_relaxed);
 
   return static_cast<uptr>(max_label_allocated);
 }
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE void
 dfsan_dump_labels(int fd) {
+  if (flags().fast16labels)
+    ReportUnsupportedFast16("dfsan_dump_labels");
+
   dfsan_label last_label =
       atomic_load(&__dfsan_last_label, memory_order_relaxed);
-
   for (uptr l = 1; l <= last_label; ++l) {
     char buf[64];
     internal_snprintf(buf, sizeof(buf), "%u %u %u ", l,
                       __dfsan_label_info[l].l1, __dfsan_label_info[l].l2);
     WriteToFile(fd, buf, internal_strlen(buf));
     if (__dfsan_label_info[l].l1 == 0 && __dfsan_label_info[l].desc) {
       WriteToFile(fd, __dfsan_label_info[l].desc,
                   internal_strlen(__dfsan_label_info[l].desc));
     }

compiler-rt/test/dfsan/fast16labels.c

-// RUN: %clang_dfsan %s -o %t && DFSAN_OPTIONS=fast16labels=1 %run %t
+// RUN: %clang_dfsan %s -o %t
+// RUN: DFSAN_OPTIONS=fast16labels=1 %run %t
+// RUN: DFSAN_OPTIONS=fast16labels=1 not %run %t dfsan_create_label 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CREATE-LABEL
+// RUN: DFSAN_OPTIONS=fast16labels=1 not %run %t dfsan_get_label_info 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=GET-LABEL-INFO
+// RUN: DFSAN_OPTIONS=fast16labels=1 not %run %t dfsan_has_label_with_desc \
+// RUN:   2>&1 | FileCheck %s --check-prefix=HAS-LABEL-WITH-DESC
+// RUN: DFSAN_OPTIONS=fast16labels=1:dump_labels_at_exit=/dev/stdout not %run \
+// RUN:   %t 2>&1 | FileCheck %s --check-prefix=DUMP-LABELS
 //
 // Tests DFSAN_OPTIONS=fast16labels=1
 //
 #include <sanitizer/dfsan_interface.h>
 
 #include <assert.h>
 #include <stdio.h>
+#include <string.h>
 
 int foo(int a, int b) {
   return a + b;
 }
 
-int main() {
+int main(int argc, char *argv[]) {
+  // Death tests for unsupported API usage.
+  const char *command = (argc < 2) ? "" : argv[1];
+  // CREATE-LABEL: FATAL: DataFlowSanitizer: dfsan_create_label is unsupported
+  if (strcmp(command, "dfsan_create_label") == 0)
+    dfsan_create_label("", NULL);
+  // GET-LABEL-INFO: FATAL: DataFlowSanitizer: dfsan_get_label_info is unsupported
+  if (strcmp(command, "dfsan_get_label_info") == 0)
+    dfsan_get_label_info(1);
+  // HAS-LABEL-WITH-DESC: FATAL: DataFlowSanitizer: dfsan_has_label_with_desc is unsupported
+  if (strcmp(command, "dfsan_has_label_with_desc") == 0)
+    dfsan_has_label_with_desc(1, "");
+  // DUMP-LABELS: FATAL: DataFlowSanitizer: dfsan_dump_labels is unsupported
+
+  // Supported usage.
   int a = 10;
   int b = 20;
   dfsan_set_label(8, &a, sizeof(a));
   dfsan_set_label(512, &b, sizeof(b));
   int c = foo(a, b);
   printf("A: 0x%x\n", dfsan_get_label(a));
   printf("B: 0x%x\n", dfsan_get_label(b));
   dfsan_label l = dfsan_get_label(c);
   printf("C: 0x%x\n", l);
   assert(l == 520);  // OR of the other two labels.
+  assert(dfsan_has_label(l, 8));
+  assert(dfsan_has_label(l, 512));
+  assert(!dfsan_has_label(l, 1));
 }