[sanitizer] Fix various issues reported by Clang Static Analyzer [NFC]

[kubamracek]

Summary

There's several issues reported by Clang Static Analyzer: Some dead stores, some potential null-pointer dereferences, and a possible garbage value read. They are all pretty straightforward, so this patch fixes them all at once. NFC.

[dvyukov]

lib/asan/asan_descriptions.cc

455

This is funny.
The code is incorrect. Your fix is incorrect. And we almost printed a wild address on wild address access. Still it worked correctly. The bug was masked by the fact that GetGlobalAddressInformation initializes first field with address when it must not, and the field is magically collocated with the addr field. So it all kinda worked in the end.

This needs to be:

data.addr = addr;

lib/tsan/rtl/tsan_stack_trace.cc

41

What's wrong with new_size=0? ResizeBuffer works for size=0, and in fact we call ResizeBuffer(0) in dtor.

lib/tsan/rtl/tsan_sync.cc

82

Is it the only potential nullptr-deref warning in sanitizer code? There are usually tons of them. So I am confused, is it really so special place? why?

lib/asan/asan_descriptions.cc

if (isStackMemory) {
     return;
   }
 
   if (GetGlobalAddressInformation(addr, access_size, &data.global)) {
     data.kind = kAddressKindGlobal;
     return;
   }
   data.kind = kAddressKindWild;
-  addr = 0;
+  data.addr = 0;
 }
 
 void PrintAddressDescription(uptr addr, uptr access_size,
                              const char *bug_type) {
   ShadowAddressDescription shadow_descr;
   if (GetShadowAddressInformation(addr, &shadow_descr)) {
     shadow_descr.Print();
     return;

lib/sanitizer_common/sanitizer_symbolizer_libcdep.cc

 
 // Parses a two-line string in the following format:
 //   <symbol_name>
 //   <start_address> <size>
 // Used by LLVMSymbolizer and InternalSymbolizer.
 void ParseSymbolizeDataOutput(const char *str, DataInfo *info) {
   str = ExtractToken(str, "\n", &info->name);
   str = ExtractUptr(str, " ", &info->start);
-  str = ExtractUptr(str, "\n", &info->size);
+  ExtractUptr(str, "\n", &info->size);
 }
 
 bool LLVMSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
   AddressInfo *info = &stack->info;
   const char *buf = FormatAndSendCommand(
       /*is_data*/ false, info->module, info->module_offset, info->module_arch);
   if (buf) {
     ParseSymbolizePCOutput(buf, stack);

lib/sanitizer_common/sanitizer_symbolizer_mac.cc

static bool ParseCommandOutput(const char *str, uptr addr, char **out_name,
   }
 
   if (internal_strncmp(symbol_name, "0x", 2) != 0)
     *out_name = symbol_name;
   else
     InternalFree(symbol_name);
   rest = ExtractTokenUpToDelimiter(rest, ") ", out_module);
 
+  if (line) *line = 0;
   if (rest[0] == '(') {
     if (out_file) {
       rest++;
       rest = ExtractTokenUpToDelimiter(rest, ":", out_file);
       char *extracted_line_number;
-      rest = ExtractTokenUpToDelimiter(rest, ")", &extracted_line_number);
+      ExtractTokenUpToDelimiter(rest, ")", &extracted_line_number);
       if (line) *line = (uptr)internal_atoll(extracted_line_number);
       InternalFree(extracted_line_number);
     }
   } else if (rest[0] == '+') {
     rest += 2;
     uptr offset = internal_atoll(rest);
     if (start_address) *start_address = addr - offset;
   }

lib/tsan/rtl/tsan_stack_trace.cc

trace_buffer =
           ? (uptr *)internal_alloc(MBlockStackTrace,
                                    new_size * sizeof(trace_buffer[0]))
           : nullptr;
   trace = trace_buffer;
   size = new_size;
 }
 
 void VarSizeStackTrace::Init(const uptr *pcs, uptr cnt, uptr extra_top_pc) {
-  ResizeBuffer(cnt + !!extra_top_pc);
+  uptr new_size = cnt + !!extra_top_pc;
+  CHECK(new_size);
+  ResizeBuffer(new_size);
   internal_memcpy(trace_buffer, pcs, cnt * sizeof(trace_buffer[0]));
   if (extra_top_pc)
     trace_buffer[cnt] = extra_top_pc;
 }
 
 }  // namespace __tsan

lib/tsan/rtl/tsan_sync.cc

uptr MetaMap::FreeBlock(Processor *proc, uptr p) {
   if (b == 0)
     return 0;
   uptr sz = RoundUpTo(b->siz, kMetaShadowCell);
   FreeRange(proc, p, sz);
   return sz;
 }
 
 bool MetaMap::FreeRange(Processor *proc, uptr p, uptr sz) {
+  CHECK(proc);
   bool has_something = false;
   u32 *meta = MemToMeta(p);
   u32 *end = MemToMeta(p + sz);
   if (end == meta)
     end++;
   for (; meta < end; meta++) {
     u32 idx = *meta;
     if (idx == 0) {