[sanitizer] Remove traces from the header

[vitalybuka]

Summary

This will simplify removing id proposed by @dvyukov on D111183
Also now we have more flexiliby for traces compressio they
are not interleaving with uncompressable headers.

Depends on D111256.

[dvyukov]

LGTM with a nit

compiler-rt/lib/sanitizer_common/sanitizer_stackdepot.cpp

45–46

I think this needs to be updated as well.

[vitalybuka]

fix size

compiler-rt/lib/sanitizer_common/sanitizer_stackdepot.cpp

 #include "sanitizer_common.h"
 #include "sanitizer_hash.h"
 #include "sanitizer_persistent_allocator.h"
 #include "sanitizer_stackdepotbase.h"
 
 namespace __sanitizer {
 
 static PersistentAllocator allocator;
+static PersistentAllocator traceAllocator;
 
 struct StackDepotNode {
   using hash_type = u64;
   hash_type stack_hash;
   StackDepotNode *link;
+  uptr *stack_trace;
   u32 id;
-  u32 size;
   atomic_uint32_t tag_and_use_count;  // tag : 12 high bits; use_count : 20;
-  uptr stack[1];  // [size]
 
   static const u32 kTabSizeLog = SANITIZER_ANDROID ? 16 : 20;
   static const u32 kUseCountBits = 20;
   static const u32 kMaxUseCount = 1 << kUseCountBits;
   static const u32 kUseCountMask = (1 << kUseCountBits) - 1;
 
   typedef StackTrace args_type;
   bool eq(hash_type hash, const args_type &args) const {
     return hash == stack_hash;
   }
-  static uptr allocated() { return allocator.allocated(); }
+  static uptr allocated() {
+    return allocator.allocated() + traceAllocator.allocated();
+  }
   static StackDepotNode *allocate(const args_type &args) {
-    uptr alloc_size = sizeof(StackDepotNode) + (args.size - 1) * sizeof(uptr);
-    return (StackDepotNode *)allocator.alloc(alloc_size);
+    return (StackDepotNode *)allocator.alloc(sizeof(StackDepotNode));
   }
   static hash_type hash(const args_type &args) {
     MurMur2Hash64Builder H(args.size * sizeof(uptr));
     for (uptr i = 0; i < args.size; i++) H.add(args.trace[i]);
     H.add(args.tag);
     return H.get();
   }
   static bool is_valid(const args_type &args) {
     return args.size > 0 && args.trace;
   }
   void store(const args_type &args, hash_type hash) {
     CHECK_EQ(args.tag & (~kUseCountMask >> kUseCountBits), args.tag);
     atomic_store(&tag_and_use_count, args.tag << kUseCountBits,
                  memory_order_relaxed);
     stack_hash = hash;
-    size = args.size;
-    internal_memcpy(stack, args.trace, size * sizeof(uptr));
+    stack_trace = (uptr *)traceAllocator.alloc((args.size + 1) * sizeof(uptr));
+    *stack_trace = args.size;
+    internal_memcpy(stack_trace + 1, args.trace, args.size * sizeof(uptr));
   }
   args_type load() const {
     u32 tag =
         atomic_load(&tag_and_use_count, memory_order_relaxed) >> kUseCountBits;
-    return args_type(&stack[0], size, tag);
+    return args_type(stack_trace + 1, *stack_trace, tag);
   }
   StackDepotHandle get_handle() { return StackDepotHandle(this); }
 
   typedef StackDepotHandle handle_type;
 };
 
 COMPILER_CHECK(StackDepotNode::kMaxUseCount >= (u32)kStackDepotMaxUseCount);