[asan] Store access_size in the {Stack,Global}AddressDescription objects

[filcab]

Summary

This is important information when we want to describe errors, and should be
part of these descriptions. Otherwise, we need to know the access size when
printing/emitting the description.

[vitalybuka]

LGTM

lib/asan/asan_descriptions.h

bool GetHeapAddressInformation(uptr addr, uptr access_size,
                                HeapAddressDescription *descr);
 bool DescribeAddressIfHeap(uptr addr, uptr access_size = 1);
 
 struct StackAddressDescription {
   uptr addr;
   uptr tid;
   uptr offset;
   uptr frame_pc;
+  uptr access_size;
   const char *frame_descr;
 
-  void Print(uptr access_size = 1);
+  void Print();
 };
 
-bool GetStackAddressInformation(uptr addr, StackAddressDescription *descr);
+bool GetStackAddressInformation(uptr addr, uptr access_size,
+                                StackAddressDescription *descr);
 bool DescribeAddressIfStack(uptr addr, uptr access_size);
 
 struct GlobalAddressDescription {
   uptr addr;
   // Assume address is close to at most four globals.
   static const int kMaxGlobals = 4;
   __asan_global globals[kMaxGlobals];
   u32 reg_sites[kMaxGlobals];
+  uptr access_size;
   u8 size;
 
-  void Print(uptr access_size = 1, const char *bug_type = "");
+  void Print(const char *bug_type = "");
 };
 
-bool GetGlobalAddressInformation(uptr addr, GlobalAddressDescription *descr);
+bool GetGlobalAddressInformation(uptr addr, uptr access_size,
+                                 GlobalAddressDescription *descr);
 bool DescribeAddressIfGlobal(uptr addr, uptr access_size, const char *bug_type);
 
 // General function to describe an address. Will try to describe the address as
 // a shadow, global (variable), stack, or heap address.
 // bug_type is optional and is used for checking if we're reporting an
 // initialization-order-fiasco
 // The proper access_size should be passed for stack, global, and heap
 // addresses. Defaults to 1.
struct AddressDescription : AddressDescriptionBase {
   AddressDescription() {
     kind = kAddressKindWild;
     addr = 0;
   }
   // shouldLockThreadRegistry allows us to skip locking if we're sure we already
   // have done it.
   AddressDescription(uptr addr, bool shouldLockThreadRegistry = true)
       : AddressDescription(addr, 1, shouldLockThreadRegistry) {}
-  AddressDescription(uptr addr, uptr length,
+  AddressDescription(uptr addr, uptr access_size,
                      bool shouldLockThreadRegistry = true) {
     if (GetShadowAddressInformation(addr, &shadow)) {
       kind = kAddressKindShadow;
       return;
     }
-    if (GetHeapAddressInformation(addr, 1, &heap)) {
+    if (GetHeapAddressInformation(addr, access_size, &heap)) {
       kind = kAddressKindHeap;
       return;
     }
 
     bool isStackMemory = false;
     if (shouldLockThreadRegistry) {
       ThreadRegistryLock l(&asanThreadRegistry());
-      isStackMemory = GetStackAddressInformation(addr, &stack);
+      isStackMemory = GetStackAddressInformation(addr, access_size, &stack);
     } else {
-      isStackMemory = GetStackAddressInformation(addr, &stack);
+      isStackMemory = GetStackAddressInformation(addr, access_size, &stack);
     }
     if (isStackMemory) {
       kind = kAddressKindStack;
       return;
     }
 
-    if (GetGlobalAddressInformation(addr, &global)) {
+    if (GetGlobalAddressInformation(addr, access_size, &global)) {
       kind = kAddressKindGlobal;
       return;
     }
     kind = kAddressKindWild;
     addr = 0;
   }
 };
 
 }  // namespace __asan
 
 #endif  // ASAN_DESCRIPTIONS_H

lib/asan/asan_descriptions.cc

Printf(
         "(wild memory access suspected).\n");
     return false;
   }
   descr.Print();
   return true;
 }
 
 // Stack descriptions
-bool GetStackAddressInformation(uptr addr, StackAddressDescription *descr) {
+bool GetStackAddressInformation(uptr addr, uptr access_size,
+                                StackAddressDescription *descr) {
   AsanThread *t = FindThreadByStackAddress(addr);
   if (!t) return false;
 
   descr->addr = addr;
   descr->tid = t->tid();
   // Try to fetch precise stack frame for this access.
   AsanThread::StackFrameAccess access;
   if (!t->GetStackFrameAccessByAddr(addr, &access)) {
     descr->frame_descr = nullptr;
     return true;
   }
 
   descr->offset = access.offset;
+  descr->access_size = access_size;
   descr->frame_pc = access.frame_pc;
   descr->frame_descr = access.frame_descr;
 
 #if SANITIZER_PPC64V1
   // On PowerPC64 ELFv1, the address of a function actually points to a
   // three-doubleword data structure with the first field containing
   // the address of the function's code.
   descr->frame_pc = *reinterpret_cast<uptr *>(descr->frame_pc);
static void PrintAccessAndVarIntersection(const StackVarDescr &var, uptr addr,
   } else {
     str.append("\n");
   }
   Printf("%s", str.data());
 }
 
 bool DescribeAddressIfStack(uptr addr, uptr access_size) {
   StackAddressDescription descr;
-  if (!GetStackAddressInformation(addr, &descr)) return false;
-  descr.Print(access_size);
+  if (!GetStackAddressInformation(addr, access_size, &descr)) return false;
+  descr.Print();
   return true;
 }
 
 // Global descriptions
 static void DescribeAddressRelativeToGlobal(uptr addr, uptr access_size,
                                             const __asan_global &g) {
   InternalScopedString str(4096);
   Decorator d;
str.append(" of global variable '%s' defined in '",
              MaybeDemangleGlobalName(g.name));
   PrintGlobalLocation(&str, g);
   str.append("' (0x%zx) of size %zu\n", g.beg, g.size);
   str.append("%s", d.EndLocation());
   PrintGlobalNameIfASCII(&str, g);
   Printf("%s", str.data());
 }
 
-bool GetGlobalAddressInformation(uptr addr, GlobalAddressDescription *descr) {
+bool GetGlobalAddressInformation(uptr addr, uptr access_size,
+                                 GlobalAddressDescription *descr) {
   descr->addr = addr;
   int globals_num = GetGlobalsForAddress(addr, descr->globals, descr->reg_sites,
                                          ARRAY_SIZE(descr->globals));
   descr->size = globals_num;
+  descr->access_size = access_size;
   return globals_num != 0;
 }
 
 bool DescribeAddressIfGlobal(uptr addr, uptr access_size,
                              const char *bug_type) {
   GlobalAddressDescription descr;
-  if (!GetGlobalAddressInformation(addr, &descr)) return false;
+  if (!GetGlobalAddressInformation(addr, access_size, &descr)) return false;
 
-  descr.Print(access_size, bug_type);
+  descr.Print(bug_type);
   return true;
 }
 
 void ShadowAddressDescription::Print() {
   Printf("Address %p is located in the %s area.\n", addr, ShadowNames[kind]);
 }
 
-void GlobalAddressDescription::Print(uptr access_size, const char *bug_type) {
+void GlobalAddressDescription::Print(const char *bug_type) {
   for (int i = 0; i < size; i++) {
     DescribeAddressRelativeToGlobal(addr, access_size, globals[i]);
     if (0 == internal_strcmp(bug_type, "initialization-order-fiasco") &&
         reg_sites[i]) {
       Printf("  registered at:\n");
       StackDepotGet(reg_sites[i]).Print();
     }
   }
 }
 
-void StackAddressDescription::Print(uptr access_size) {
+void StackAddressDescription::Print() {
   Decorator d;
   char tname[128];
   Printf("%s", d.Location());
   Printf("Address %p is located in stack of thread T%d%s", addr, tid,
          ThreadNameWithParenthesis(tid, tname, sizeof(tname)));
 
   if (!frame_descr) {
     Printf("%s\n", d.EndLocation());
void PrintAddressDescription(uptr addr, uptr access_size,
                              const char *bug_type) {
   ShadowAddressDescription shadow_descr;
   if (GetShadowAddressInformation(addr, &shadow_descr)) {
     shadow_descr.Print();
     return;
   }
 
   GlobalAddressDescription global_descr;
-  if (GetGlobalAddressInformation(addr, &global_descr)) {
-    global_descr.Print(access_size, bug_type);
+  if (GetGlobalAddressInformation(addr, access_size, &global_descr)) {
+    global_descr.Print(bug_type);
     return;
   }
 
   StackAddressDescription stack_descr;
-  if (GetStackAddressInformation(addr, &stack_descr)) {
-    stack_descr.Print(access_size);
+  if (GetStackAddressInformation(addr, access_size, &stack_descr)) {
+    stack_descr.Print();
     return;
   }
 
   HeapAddressDescription heap_descr;
   if (GetHeapAddressInformation(addr, access_size, &heap_descr)) {
     heap_descr.Print();
     return;
   }
 
   // We exhausted our possibilities. Bail out.
   Printf(
       "AddressSanitizer can not describe address in more detail "
       "(wild memory access suspected).\n");
 }
 }  // namespace __asan